# Prynt public API: GraphQL schema. Generated from the API, do not edit by hand. # operation Mutation.addAdditionalCost beta since 0.28.0 # operation Mutation.assignClientTag beta since 0.28.0 # operation Mutation.completeFileUpload beta since 0.28.0 # operation Mutation.createClient beta since 0.28.0 # operation Mutation.createClientAddress beta since 0.28.0 # operation Mutation.createClientContact beta since 0.28.0 # operation Mutation.createClientNote beta since 0.28.0 # operation Mutation.createOrder beta since 0.28.0 # operation Mutation.createOrderPayment beta since 0.28.0 # operation Mutation.createProduct beta since 0.28.0 # operation Mutation.createPurchaseOrder beta since 0.28.0 # operation Mutation.createSupplier beta since 0.28.0 # operation Mutation.initiateFileUpload beta since 0.28.0 # operation Mutation.receiveFoil beta since 0.28.0 # operation Mutation.receivePaint beta since 0.28.0 # operation Mutation.receivePaper beta since 0.28.0 # operation Mutation.receivePurchaseOrder beta since 0.28.0 # operation Mutation.removeClientTag beta since 0.28.0 # operation Mutation.updateAdditionalCost beta since 0.28.0 # operation Mutation.updateClient beta since 0.28.0 # operation Mutation.updateClientAddress beta since 0.28.0 # operation Mutation.updateClientContact beta since 0.28.0 # operation Mutation.updateClientNote beta since 0.28.0 # operation Mutation.updateOperation beta since 0.33.0 # operation Mutation.updateOrder beta since 0.28.0 # operation Mutation.updateProduct beta since 0.28.0 # operation Mutation.updatePurchaseOrder beta since 0.28.0 # operation Mutation.updatePurchaseOrderStatus beta since 0.28.0 # operation Mutation.updateSupplier beta since 0.28.0 # operation Mutation.withdrawFoil beta since 0.28.0 # operation Mutation.withdrawPaint beta since 0.28.0 # operation Mutation.withdrawPaper beta since 0.28.0 # operation Query.billingEntities beta since 0.28.0 # operation Query.billingEntity beta since 0.28.0 # operation Query.client beta since 0.28.0 # operation Query.clients beta since 0.28.0 # operation Query.clientTags beta since 0.28.0 # operation Query.currencies beta since 0.28.0 # operation Query.currentApiKey beta since 0.28.0 # operation Query.dieCut beta since 0.28.0 # operation Query.dieCuts beta since 0.28.0 # operation Query.foil beta since 0.28.0 # operation Query.foils beta since 0.28.0 # operation Query.machine beta since 0.28.0 # operation Query.machines beta since 0.28.0 # operation Query.matrices beta since 0.28.0 # operation Query.matrix beta since 0.28.0 # operation Query.operation beta since 0.33.0 # operation Query.operations beta since 0.33.0 # operation Query.order beta since 0.28.0 # operation Query.orders beta since 0.28.0 # operation Query.paint beta since 0.28.0 # operation Query.paints beta since 0.28.0 # operation Query.paper beta since 0.28.0 # operation Query.papers beta since 0.28.0 # operation Query.product beta since 0.28.0 # operation Query.productInvoice beta since 0.28.0 # operation Query.productInvoices beta since 0.28.0 # operation Query.purchaseInvoice beta since 0.28.0 # operation Query.purchaseInvoices beta since 0.28.0 # operation Query.purchaseOrder beta since 0.28.0 # operation Query.purchaseOrders beta since 0.28.0 # operation Query.referenceData beta since 0.28.0 # operation Query.stockMovements beta since 0.28.0 # operation Query.stockTake beta since 0.28.0 # operation Query.stockTakes beta since 0.28.0 # operation Query.supplier beta since 0.28.0 # operation Query.suppliers beta since 0.28.0 # operation Query.task beta since 0.28.0 # operation Query.tasks beta since 0.28.0 # operation Query.vatRates beta since 0.28.0 """A new additional cost, charged on an order or on one of its products.""" input AddAdditionalCostInput { """Net amount of the cost in the order currency, 0 or more.""" amount: Float! """Kind of cost.""" category: AdditionalCostCategory """Longer description of the cost (up to 2000 characters).""" description: String """True to show the cost to the client, for example on the order summary.""" isClientVisible: Boolean = true """Name of the cost, as shown on documents (up to 200 characters).""" name: String! """ Identifier of the order to charge the cost on. Required when calling with an API key (an order is the only parent a key may give); the order must not be archived. """ orderId: ID """ Identifier of a product of that order to charge the cost on; without it the cost is on the whole order. """ productId: ID """Position of the cost among the costs of the order, from 0.""" sortOrder: Int = 0 """VAT rate as a fraction from 0 to 1: `0.23` for 23%.""" taxRate: Float = 0.23 } """ An additional cost charged on an order or one of its products, for example design work or express handling. """ type AdditionalCost { """Net amount of the cost, in the order currency.""" amount: Float! """Kind of cost; null when not categorised.""" category: AdditionalCostCategory """When the cost was added.""" createdAt: DateTime! """Longer description of the cost; null when empty.""" description: String """Identifier of the additional cost (UUID).""" id: ID! """ True when the cost is shown to the client (for example on the order summary). """ isClientVisible: Boolean! """Name of the cost, as shown on documents.""" name: String! """Identifier of the order the cost is charged on.""" orderId: ID """ Identifier of the product the cost is charged on; null for a cost of the whole order. """ productId: ID """Position of the cost among the costs of the order, from 0.""" sortOrder: Int! """VAT rate as a fraction, for example `0.23` for 23%.""" taxRate: Float! } """Kind of an additional cost.""" enum AdditionalCostCategory { """Printing plates (CTP).""" CTP_PLATES """Custom finishing.""" CUSTOM_FINISHING """Delivery insurance.""" DELIVERY_INSURANCE """Design work.""" DESIGN """A die-cutting tool made for the job.""" DIE_CUT_TOOLING """A service bought from a subcontractor.""" EXTERNAL_SERVICE """Material surcharge.""" MATERIAL_SURCHARGE """Another cost.""" OTHER """Prepress work.""" PREPRESS """Proofs.""" PROOFING """Express surcharge.""" RUSH_FEE """Special packaging.""" SPECIAL_PACKAGING """Waste disposal fee.""" WASTE_FEE } """One page of billing entities and the size of the whole list.""" type BillingEntitiesResult { """Billing entities on this page, in the requested sort order.""" items: [BillingEntity!]! """Where this page is in the list and whether more pages follow.""" pageInfo: PageInfo! """ Number of items matching the filter on all pages together, not only on this one. """ totalCount: Int! } """ A company of the print shop that invoices its orders (a billing entity): the seller's data on its invoices. A print shop may invoice through more than one. It may be a sole trader: then its name is the owner's full name and the address may be a home address — treat it as personal data. """ type BillingEntity { """ Bank account number for payments (IBAN or domestic, up to 34 characters). """ accountNumber: String! """Building number of the registered address; null when not set.""" buildingNumber: String """City of the registered address; null when not set.""" city: String """ True when the company holds an FSC chain-of-custody certificate (it may sell FSC products). """ fscCertificate: Boolean! """Identifier of the billing entity (UUID).""" id: ID! """KRS court register number; null when not set.""" krs: String """ Full legal name of the company (of a sole trader: the owner's name and the business name). """ name: String! """Short name of the company; null when not set.""" nameShort: String """Tax identification number (NIP), exactly 10 digits.""" nip: String! """REGON statistical number; null when not set.""" regon: String """Street of the registered address; null when not set.""" street: String """Postal code of the registered address; null when not set.""" zip: String } """ Conditions on billing entities: an entity is listed when it meets every condition given. Omitted conditions do not filter. """ input BillingEntityFilterInput { """Entities whose full legal name contains this text (case-insensitive).""" name: String """Entities whose tax identification number (NIP) contains this text.""" nip: String } """ What to sort billing entities by. Entities with equal values keep a fixed order (by identifier), so pages do not overlap. """ enum BillingEntitySortField { """When the entity was added.""" CREATED_AT """Full legal name.""" NAME """Tax identification number (NIP).""" NIP } """How to sort billing entities.""" input BillingEntitySortInput { """Ascending or descending.""" direction: SortDirection! """What to sort by.""" field: BillingEntitySortField! } """ A client of the print shop — a company, a sole proprietorship or an individual — with its contact persons, addresses, CRM notes and tags. A text field is null when it was not given. """ type Client { """ Addresses of the client: the default ones first, then the oldest. An empty list (never null) when it has none. """ addresses: [ClientAddress!] """ Whether the print shop takes and releases orders of the client. Only the print shop sets it: an integration cannot place an order for a client blocked with `BLOCK_ALL`. """ blockMode: ClientBlockMode! """Why the print shop blocked the client; null when not blocked.""" blockReason: String """When the current block was set; null when not blocked.""" blockedAt: DateTime """ The latest CRM notes about the client (calls, meetings, e-mails), the latest contact first: `first` of them, at most 50. Private notes of the staff never show; an empty list (never null) when there are none. """ clientNotes( """How many of the latest notes to return: 1 to 50 (25 when not given).""" first: Int! = 25 ): [ClientNote!] """ Contact persons of the client: the primary one first, then by last and first name. An empty list (never null) when it has none. """ contacts: [ClientContact!] """When the client was added.""" createdAt: DateTime! """ Credit limit of the client in the print shop's home currency: how much it may owe for unpaid orders. 0 or null: no limit is tracked. Only the print shop sets it. """ creditLimit: Float """Payment term of the client's orders, in days.""" daysToPay: Int """ Identifier of the default currency of the client's orders; null for the print shop's home currency. """ defaultCurrencyId: ID """How the client's orders are delivered by default.""" defaultDeliveryMethod: DeliveryMethod """ Identifier of the print shop's billing entity that invoices the client's orders by default; null while none is chosen. """ defaultInvoiceBillingEntityId: ID """How the client pays for orders by default.""" defaultPaymentMethod: PaymentMethod """ Default discount of the client in percent (10 = 10%); null when none. Only the print shop sets it. """ discountPercent: Float """ Name Prynt shows for the client: the legal name of a company, the first and last name of an individual. Derived from the name fields. """ displayName: String! """E-mail address of the client.""" email: String """EU VAT identification number, for supplies within the EU.""" euVatNumber: String """ Your integration's own identifier of the client (`CreateClientInput.externalRef`); null until you set one. Each integration sees only its own; in the app it is always null. """ externalRef: String """First name of an individual or a sole proprietor.""" firstName: String """Identifier of the client (UUID).""" id: ID! """ False when the print shop deactivated the client (in Prynt, deleting a client deactivates it). An API key does not change a deactivated client or order for it. """ isActive: Boolean! """KRS, the Polish court register number.""" krs: String """Last name of an individual or a sole proprietor.""" lastName: String """Legal name of a company or a sole proprietorship, as on invoices.""" legalName: String """Short name the print shop uses in lists.""" nameShort: String """Phone number of the client.""" phone: String """REGON, the Polish statistical business number.""" regon: String """ Tags of the client, by name. An empty list (never null) when it has none. """ tags: [ClientTag!] """ Tax identification number (NIP), unique among the print shop's clients. """ taxIdentificationNumber: String """Kind of client; it decides which name fields are set.""" type: ClientType! """ When the client or anything of it (contacts, addresses, notes visible to integrations, tags) last changed. Writing back the same values does not move it. Filter on it with `updatedFrom` to fetch only what changed since your last sync. """ updatedAt: DateTime! } """ An address of a client: its headquarters, a delivery address, a warehouse, a billing address. A text field is null when it was not given. """ type ClientAddress { """Building and apartment number, for example `12A/3`.""" buildingNumber: String """City.""" city: String! """Identifier of the client.""" clientId: ID! """When the place closes, `HH:mm` (deliveries).""" closesAt: String """Country, as entered, for example `Polska`.""" country: String! """When the address was added.""" createdAt: DateTime! """E-mail address at the address.""" email: String """Identifier of the address (UUID).""" id: ID! """ True for the default address of its type; a client has at most one per type. """ isDefault: Boolean! """Own label of the address, for example `Magazyn Poznan`.""" label: String """ Name at the address: the company or the person goods go to. Unique among the addresses of one client. """ name: String! """Short name.""" nameShort: String """Remarks for deliveries, for example the gate to use.""" notes: String """When the place opens, `HH:mm` (deliveries).""" opensAt: String """Phone number at the address.""" phone: String """Street, without the number.""" street: String! """ Code of the address type: `HEADQUARTERS`, `DELIVERY`, `WAREHOUSE`, `BILLING`, `OTHER`, or a type the print shop added. """ type: String! """Postal code; a Polish one in the `00-000` format.""" zip: String! } """ A new address of a client: type, name, city, street, zip and country are required. """ input ClientAddressInput { """ Building and apartment number, for example `12A/3` (up to 20 characters). On update, null clears it. """ buildingNumber: String """City.""" city: String! """When the place closes, `HH:mm`. On update, null clears it.""" closesAt: String """Country, for example `Polska`.""" country: String! """E-mail address at the address. On update, null clears it.""" email: String """ True makes it the default address of its type (the previous default one stops being it). False when not given on create; left out on update keeps it. """ isDefault: Boolean """ Own label of the address (up to 100 characters). On update, null clears it. """ label: String """ Name at the address: the company or the person goods go to (up to 255 characters). Unique among the addresses of the client. """ name: String! """Short name (up to 100 characters). On update, null clears it.""" nameShort: String """ Remarks for deliveries (up to 2000 characters). On update, null clears it. """ notes: String """When the place opens, `HH:mm`. On update, null clears it.""" opensAt: String """ Phone number at the address (up to 15 characters). On update, null clears it. """ phone: String """Street, without the number.""" street: String! """ Code of the address type: `HEADQUARTERS`, `DELIVERY`, `WAREHOUSE`, `BILLING`, `OTHER`, or a code the print shop added. An unknown code is refused. """ type: String! """ Postal code; a Polish one must be `00-000` (`00000` is accepted and stored as `00-000`). """ zip: String! } """ Whether the print shop takes and releases orders of a client — usually for unpaid invoices. Set by the print shop only. """ enum ClientBlockMode { """ Orders are made, but the goods are released only when the print shop agrees (for example after payment). """ ALLOW_PRODUCTION_NO_RELEASE """ The print shop takes and makes no orders of the client; the API refuses a new order for it. """ BLOCK_ALL """Not blocked.""" NONE } """ A contact person of a client — someone who orders or receives goods — from the client's address book (not a user of Prynt). A text field is null when it was not given. """ type ClientContact { """ True when the courier must give this person notice before delivery (awizo). """ awizo: Boolean! """Identifier of the client.""" clientId: ID! """When the contact was added.""" createdAt: DateTime! """E-mail address.""" email: String """First name.""" firstName: String """Identifier of the contact (UUID).""" id: ID! """ False when the person no longer acts for the client (kept for history). """ isActive: Boolean! """True for the client's main contact; a client has at most one.""" isPrimary: Boolean! """ True for the contact that stands for the client itself (an individual or a sole proprietor): Prynt keeps its name, e-mail and phone in step with the client, so change them on the client, not here. """ isSelf: Boolean! """Last name.""" lastName: String """Remarks about the person.""" notes: String """Phone number, as entered (up to 20 characters).""" phone: String """True when the orders of this person must be FSC certified.""" requiresFsc: Boolean! """Role or position of the person at the client, for example `Zakupy`.""" role: String } """ A contact person of a client. On create it needs at least a name, an e-mail or a phone; on update a field left out keeps its value. """ input ClientContactInput { """ True when the courier must give notice before delivery (awizo). False when not given on create. """ awizo: Boolean """E-mail address. On update, null clears it.""" email: String """First name (up to 255 characters). On update, null clears it.""" firstName: String """ False when the person no longer acts for the client. True when not given on create. """ isActive: Boolean """ True makes the person the primary contact of the client (the previous one stops being it). False when not given on create. """ isPrimary: Boolean """Last name (up to 255 characters). On update, null clears it.""" lastName: String """ Remarks about the person (up to 2000 characters). On update, null clears it. """ notes: String """Phone number (up to 20 characters). On update, null clears it.""" phone: String """ True when the orders of this person must be FSC certified. False when not given on create. """ requiresFsc: Boolean """ Role or position at the client, for example `Zakupy` (up to 100 characters). On update, null clears it. """ role: String } """ Conditions on clients: a client is listed when it meets every condition given. Omitted conditions do not filter. """ input ClientFilterInput { """ Clients with an address in a city containing this text (case-insensitive). """ city: String """Clients whose e-mail address contains this text (case-insensitive).""" email: String """ The client your integration gave this `externalRef` (exact match): at most one client. A person in the app has no references, so for them it matches none. """ externalRef: String """Only active (true) or only inactive (false) clients.""" isActive: Boolean """Clients whose display name contains this text (case-insensitive).""" name: String """Clients whose phone number contains these characters.""" phone: String """ Clients whose names, NIP, phone, e-mail or address city contain this text (case-insensitive). """ search: String """Clients having at least one of these tags.""" tagIds: [ID!] """ Clients whose tax identification number (NIP) contains these characters. Send the digits as Prynt stores them; compare the whole number yourself when you look one client up. """ taxIdentificationNumber: String """Clients of this kind.""" type: ClientType """ Clients that changed at or after this moment (inclusive), as `Client.updatedAt` shows it. For incremental sync: pass the latest `updatedAt` you have seen, minus a few minutes, and sort by `UPDATED_AT`. Null or left out: no bound (the first run of a sync reads every client). """ updatedFrom: DateTime } """ A CRM note about a client: a call, a meeting, an e-mail or a plain note, by a member of the staff or an integration. """ type ClientNote { """ Name of the integration that wrote the note; for people in the app also the first and last name of the staff member who wrote it. An API key reads null for a note by the print shop's staff: staff names are not part of the API. """ authorName: String """Identifier of the client.""" clientId: ID! """When the contact the note records took place.""" contactDate: DateTime! """Text of the note.""" content: String! """When the note was written.""" createdAt: DateTime! """ Day to follow the contact up (UTC midnight of that day); null when none. """ followUpDate: DateTime """Identifier of the note (UUID).""" id: ID! """ Identifier of the order of this client the note is about; null when none. """ relatedOrderId: ID """What the note records.""" type: ClientNoteType! } """What a CRM note records.""" enum ClientNoteType { """A phone call.""" CALL """An e-mail.""" EMAIL """A meeting.""" MEETING """A plain note.""" NOTE """Anything else.""" OTHER } """ What to sort clients by. Clients with equal values keep a fixed order (by identifier), so pages do not overlap. """ enum ClientSortField { """When the client was added.""" CREATED_AT """Display name of the client (`displayName`).""" NAME """ Tax identification number; clients without one come last when ascending, first when descending. """ TAX_ID """ When the client or anything of it last changed (`Client.updatedAt`). Ascending, with `updatedFrom`, for incremental sync. """ UPDATED_AT } """How to sort clients.""" input ClientSortInput { """Ascending or descending.""" direction: SortDirection! """What to sort by.""" field: ClientSortField! } """ A tag the print shop marks clients with, for example `VIP` or `Hurt`. The print shop manages the list in Prynt. """ type ClientTag { """Color of the tag in Prynt, `#RRGGBB`; null for the default.""" color: String """Identifier of the tag (UUID).""" id: ID! """Name of the tag, unique.""" name: String! } """Kind of client.""" enum ClientType { """A company: legal name and tax number (NIP) required.""" COMPANY """A private person: first and last name required.""" INDIVIDUAL """ A sole proprietorship: legal name and the owner's first and last name required. """ SOLE_PROPRIETOR } """Paginated list of clients.""" type ClientsResult { """Client items for the current page.""" items: [Client!]! """Where this page is in the list and whether more pages follow.""" pageInfo: PageInfo! """ Number of items matching the filter on all pages together, not only on this one. """ totalCount: Int! } """The file whose upload to complete.""" input CompleteUploadInput { """Identifier of the file, as `initiateFileUpload` returned it.""" fileId: ID! } """ A new client: a company, a sole proprietorship or an individual. Which name fields are required follows from `type`. """ input CreateClientInput { """ Building and apartment number of the headquarters address, for example `12A/3`. """ buildingNumber: String """ City of the headquarters address. Prynt saves the headquarters address with the client when `city`, `street` and `zip` are all given. """ city: String """Country of the headquarters address (`Polska` when not given).""" country: String """ How the client's orders are delivered by default. On update, null clears it. """ defaultDeliveryMethod: DeliveryMethod """ E-mail address of the client (up to 200 characters). On update, null clears it. """ email: String """ EU VAT identification number, for supplies within the EU (up to 20 characters). On update, null clears it. """ euVatNumber: String """ Your own identifier of the client, for example its id in your CRM or web shop (1 to 100 characters). Unique within your integration and visible only to it; find the client by it with the `externalRef` filter. Only an API key sets it. On update, null removes it. """ externalRef: String """ First name of an individual or a sole proprietor (up to 100 characters). Required, with `lastName`, for `INDIVIDUAL` and `SOLE_PROPRIETOR`. On update, null clears it. """ firstName: String """ KRS, the Polish court register number (up to 10 characters). On update, null clears it. """ krs: String """ Last name of an individual or a sole proprietor (up to 100 characters). On update, null clears it. """ lastName: String """ Legal name of a company or a sole proprietorship, as on invoices (up to 200 characters). Required for `COMPANY` and `SOLE_PROPRIETOR`. On update, null clears it. """ legalName: String """ Short name the print shop uses in lists (up to 100 characters). On update, null clears it. """ nameShort: String """ Phone number of the client, up to 15 characters: send it without spaces or brackets, for example `+48221002030`. On update, null clears it. """ phone: String """ REGON, the Polish statistical business number (up to 14 characters). On update, null clears it. """ regon: String """Street of the headquarters address, without the number.""" street: String """ Identifiers of the tags the client has (`clientTags` lists them), as a whole set: on update it replaces the current tags and an empty list removes every tag; left out, the tags stay as they are. """ tagIds: [ID!] """ Tax identification number (NIP), unique among the print shop's clients (up to 20 characters). Send digits only, for example `5213000001`: Prynt stores and finds it as sent, so `521-300-00-01` is another number. Required for `COMPANY`. On update, null clears it. """ taxIdentificationNumber: String """ Kind of client: `COMPANY` (the default), `SOLE_PROPRIETOR` or `INDIVIDUAL`. It decides which name fields are required. """ type: ClientType! = COMPANY """ Postal code of the headquarters address; a Polish one is stored as `00-000`. """ zip: String } """A new CRM note about a client.""" input CreateClientNoteInput { """Identifier of the client.""" clientId: ID! """ When the contact the note records took place (date and time, ISO 8601). """ contactDate: DateTime! """Text of the note (1 to 10000 characters).""" content: String! """ Identifier of an order of this client the note is about. An order of another client is refused. """ relatedOrderId: ID """What the note records.""" type: ClientNoteType! } """ A new order. It starts as `CREATED`; Prynt numbers it and records the integration as its author. """ input CreateOrderInput { """ Additional costs of the whole order, in the order they are to be listed. """ additionalCosts: [OrderAdditionalCostInput!] """Identifier of the print shop's billing entity that invoices the order.""" billingEntityId: ID """ Identifier of the client (the print shop's customer) the order is for. The client must exist in Prynt, and an API key cannot order for a client the print shop has blocked from ordering or deactivated. """ clientId: ID! """ When the order is due to be completed: an ISO 8601 date-time, or a date meaning midnight UTC at its start. """ completionDate: String """ Person to contact about the order, as a whole: fields left out are empty. On a changed order it replaces the saved contact; left out, the saved contact stays. """ contact: OrderContactInput """ Identifier of the order currency. Setting it fixes `Order.exchangeRate` at the rate of the completion date (or of today). Left out: a new order is in the print shop's home currency; a changed order keeps its currency and rate. """ currencyId: ID """ Delivery addresses, in the order to list them. On a changed order they replace all saved addresses (an empty list removes them, for example for pickup); left out, the saved addresses stay. """ deliveries: [OrderDeliveryInput!] """ Billing details for the invoice, as a whole: fields left out are empty. On a changed order they replace the saved details; left out, the saved details stay. """ invoice: OrderInvoiceInput """ True when `completionDate` is a strict deadline. Left out: false on a new order; a changed order keeps the flag. """ isDeadline: Boolean """Day by which the client should pay, as an ISO 8601 date.""" paymentDueDate: String """How the client pays.""" paymentMethod: PaymentMethod """ Where payment of the order stands. Left out: `PENDING` on a new order; a changed order keeps its payment status. """ paymentStatus: PaymentStatus """Products of the order, each with its elements and operations.""" products: [OrderProductInput!] """Number of packages the whole order ships in, 0 or more.""" totalPackages: Int! """Number of pallets the whole order ships on, 0 or more.""" totalPallets: Int! """ How the order reaches the client. Left out: `TO_BE_AGREED` on a new order; a changed order keeps its method. """ transportMethod: TransportMethod """ Net price of transport in the order currency, 0 or more; leave it out when not charged separately. """ transportPrice: Float } """A payment received for an order.""" input CreateOrderPaymentInput { """ Amount paid, at least 0.01, in the order currency. Overpaying is allowed. """ amount: Float! """ ISO 4217 code of the currency, used only when the order has no currency of its own: payments are recorded in the order currency. """ currency: String = "PLN" """How the client paid.""" method: PaymentMethod! """Free-text note.""" notes: String """Identifier of the order the payment is for.""" orderId: ID! """ When the payment was received (ISO 8601); without it, now. It fixes the exchange rate to the home currency. """ paidAt: String """ Reference of the payment, for example the transfer title or an invoice number (up to 100 characters). """ reference: String } """ A product to add to an existing order. Elements and operations come with the order or from the print shop. """ input CreateProductInput { """ True when delivery must be announced to the recipient in advance (advice note). """ awizo: Boolean """Day the product is due (ISO 8601 date).""" dateDue: String """True when the product is made of FSC-certified paper.""" isFsc: Boolean """True to hide the product (it stays part of the order).""" isHidden: Boolean """ISBN or ISSN of a publication (up to 32 characters).""" isbnIssn: String """Name of the product, for example `Ulotka A5`.""" name: String! """ True when the product is not to be invoiced; information for the office only. """ noInvoice: Boolean """ Position of the product within its order, from 1; must not be taken by another product of the order. """ number: Int! """ Identifier of the order the product belongs to; the order must not be archived. """ orderId: ID! """When the product is planned to be packed (ISO 8601).""" packingDate: String """ Net price of the whole product line (all `quantity` units together, not per unit), in the order currency, 0 or more. """ price: Float! """ Net markup added to `price`, as an amount in the order currency (not a percentage), 0 or more. """ priceMarkup: Float! """Print run: how many units to make, in `unit`, 0 or more.""" quantity: Float! """ VAT rate in percent, from 0 to 100: `23` for 23%. A value between 0 and 1 is refused as a fraction sent by mistake (`Product.taxRate` returns the rate as a fraction: `0.23`). """ taxRate: Float! """Unit of `quantity`.""" unit: Unit! """Weight of the whole product line in kilograms, 0 or more.""" weight: Float! } """ A purchase order to a supplier, created as DRAFT. Its net total is the sum of quantity x unit price of its items. """ input CreatePurchaseOrderInput { """ Currency of the prices, a 3-letter code such as PLN or EUR. Default PLN. """ currency: String! = "PLN" """When the delivery is expected; null when unknown.""" expectedDeliveryAt: DateTime """ Your own identifier of the purchase order, e.g. its number in your purchasing system or the supplier's portal (1 to 100 characters). Unique within your integration and visible only to it; find the order by it with the `externalRef` filter, so you create it only once. Only an API key sets it. """ externalRef: String """What is ordered.""" items: [CreatePurchaseOrderItemInput!]! """Notes about the order; null when none.""" notes: String """When the order was placed; default now.""" orderedAt: DateTime """ The supplier the goods are ordered from (`Query.suppliers`); from an API key it must be active (`Supplier.isActive`). """ supplierId: ID! } """An item of a new purchase order.""" input CreatePurchaseOrderItemInput { """What is ordered, as the supplier names it (up to 300 characters).""" description: String! """ The paper, paint or foil (by `materialType`) whose stock a delivery of this item raises; null for goods kept outside the warehouse stock. Must exist and match `materialType`. """ materialId: ID """Kind of material ordered.""" materialType: MaterialType! """A note about the item; null when none.""" notes: String """Quantity ordered, in `unit`, zero or more.""" quantity: Float! """ Unit the quantity is in, as text (up to 20 characters, compared without case). An item with a material (`materialId`) must use a unit its stock can be counted in, so a delivery lands in the stock: paper ark., ark, arkusz, arkusze, arkuszy, szt, szt., sheet, sheets (sheets); paint g, gram, grams, kg (kg x 1000 = grams); foil rolki, rolka, rolek, rol., roll, rolls, m, mb, mb. (rolls; meters are divided by `Foil.metersPerRoll`). From an API key, the unit of an item that already received goods cannot change. Default szt, which fits paper only: give the unit of a paint or foil item with a material. """ unit: String! = "szt" """ Net price of one `unit`, in the currency of the purchase order (up to 4 decimals), zero or more. """ unitPrice: Float! } """A new supplier of warehouse materials. A field left out stays empty.""" input CreateSupplierInput { """Address of the supplier, as one text.""" address: String """ Short code of the supplier, unique (up to 20 characters); a code another supplier has is refused. """ code: String """Contact person at the supplier (up to 200 characters).""" contactPerson: String """Contact e-mail address (up to 200 characters).""" email: String """Name of the supplier (1 to 200 characters).""" name: String! """Tax identification number (NIP), up to 20 characters.""" nip: String """Contact phone number (up to 50 characters).""" phone: String } """ A currency the print shop sells in. Orders keep the exchange rate they were priced at (`Order.exchangeRate`). """ type Currency { """ISO 4217 code of the currency, for example `EUR`.""" code: String! """ Fallback rate of the currency into the print shop home currency (1 for the home currency), set by the print shop: used only when no rate of the National Bank of Poland is available. """ exchangeRate: Float! """Identifier of the currency (UUID).""" id: ID! """ False when the print shop no longer offers the currency (older orders may still use it). """ isActive: Boolean! """ True for the print shop home currency, in which amounts without a currency are expressed. """ isDefault: Boolean! """Name of the currency in the print shop.""" name: String! """Position of the currency in the print shop lists, from 0.""" sortOrder: Int! """Symbol shown next to amounts, for example `€`.""" symbol: String! } """ The API key a request was made with: whose it is, what it may do now and until when. Never contains the key itself. """ type CurrentApiKey { """ When Prynt's approval of the integration ends: from then on no key of the integration works, so a new key does not help. Always set today; null is reserved for an approval without an end date, which Prynt does not grant yet. """ approvalExpiresAt: DateTime """ When the key stops working. Rotate it before then: an integration may have two keys at a time. """ expiresAt: DateTime! """ Last four characters of the key, for example `k3Fq` (Prynt shows the key as `prynt_…k3Fq`): tells which key of the integration is in use. """ hint: String! """The integration the key belongs to.""" integration: CurrentApiKeyIntegration! """ Requests per minute the integration may send, all of its keys together. The `RateLimit-*` response headers show what is left. """ rateLimitPerMinute: Int! """ Scopes the key may use now, for example `orders:read` — the same for every key of the integration. Prynt approves them; the scopes page of the developer documentation explains each one. """ scopes: [String!]! } """ The integration an API key belongs to: the account Prynt shows as the author of its changes. """ type CurrentApiKeyIntegration { """Identifier of the integration.""" id: ID! """ Name of the integration, as the print shop sees it in Prynt (for example on records it created). """ name: String! } """ A date-time string at UTC, such as 2019-12-03T09:54:33Z, compliant with the date-time format. """ scalar DateTime """ How a client's orders are delivered by default (the order's `TransportMethod` follows it). """ enum DeliveryMethod { """Courier shipment.""" COURIER """Dedicated transport.""" DEDICATED """InPost shipment.""" INPOST """ The print shop's own transport: the older value of `WE_DELIVER`, still on clients saved before it. """ OWN_TRANSPORT @deprecated(reason: "Use `WE_DELIVER`: the same transport. Clients saved earlier may still read `OWN_TRANSPORT`.") """Pallet shipment.""" PALLET """The client picks the order up at the print shop.""" PICKUP """Agreed with each order.""" TO_BE_AGREED """The print shop's own transport.""" WE_DELIVER } """ A die-cut (cutting die) kept in the warehouse: a tool, counted by uses, not by stock. """ type DieCut { """When the die-cut was archived (taken out of use); null while in use.""" archivedAt: DateTime """ The client the die-cut was made for (`Query.client`, with `clients:read`); null when none. """ clientId: ID """Warehouse code of the die-cut, unique, e.g. "I242" or "K27".""" code: String! """When the die-cut was added.""" createdAt: DateTime! """Description of the die-cut; null when none.""" description: String """How many times the die-cut was used (editions cut with it).""" editionCount: Int! """Identifier of the die-cut.""" id: ID! """When the die-cut was last used; null when never.""" lastIssuedAt: DateTime """Warehouse location, e.g. "A 1 2"; null when not set.""" location: String """Whether the die-cut is marked for disposal.""" markedForDeletion: Boolean! """Name of the die-cut.""" name: String! """Whether the die-cut needs to be remade.""" needsRegeneration: Boolean! """ Number of the order the die-cut was first made for, as text; null when not recorded. """ orderNumber: String """Kind of die-cut as text, e.g. a box or a folder; null when not set.""" type: String """ When the die-cut last changed: an edit that changes a field, a use, archiving or restoring (saving the same values, or archiving it again, changes nothing). What `updatedFrom` and the `UPDATED_AT` sort read. """ updatedAt: DateTime! } """ Conditions on die-cuts: a die-cut is listed when it meets every condition given. Omitted conditions do not filter. """ input DieCutFilterInput { """Die-cuts made for this client.""" clientId: ID """Die-cuts whose code contains this text (case-insensitive).""" code: String """ True: only archived die-cuts; false: only die-cuts in use. Left out: die-cuts in use, but with `updatedFrom` archived ones too, so a sync sees a die-cut being archived (`archivedAt`). """ isArchived: Boolean """ Die-cuts whose warehouse location contains this text (case-insensitive). """ location: String """Die-cuts that are (true) or are not (false) marked for disposal.""" markedForDeletion: Boolean """Die-cuts whose name contains this text (case-insensitive).""" nameContains: String """Die-cuts that do (true) or do not (false) need remaking.""" needsRegeneration: Boolean """Die-cuts whose kind (`type`) contains this text (case-insensitive).""" type: String """ Only die-cuts that changed at or after this moment (inclusive), as `DieCut.updatedAt` shows it. For incremental sync: pass the latest `updatedAt` you have seen, minus a few minutes, and sort by `UPDATED_AT` ascending. Null or left out: no bound (the first run of a sync reads every one). """ updatedFrom: DateTime } """ What to sort die-cuts by. Die-cuts with equal values keep a fixed order (by identifier), so pages do not overlap. """ enum DieCutSortField { """Identifier of the client the die-cut was made for.""" CLIENT """Warehouse code of the die-cut.""" CODE """When the die-cut was added.""" CREATED_AT """How many times the die-cut was used.""" EDITION_COUNT """When the die-cut was last used.""" LAST_ISSUED_AT """Name of the die-cut.""" NAME """Kind of die-cut, as text.""" TYPE """ When the record last changed (`DieCut.updatedAt`). Ascending, with `updatedFrom`, for incremental sync. """ UPDATED_AT } """How to sort die-cuts.""" input DieCutSortInput { """Ascending or descending.""" direction: SortDirection! """What to sort by.""" field: DieCutSortField! } """One page of die-cuts and the size of the whole list.""" type DieCutsResult { """Die-cuts on this page, in the requested sort order.""" items: [DieCut!]! """Where this page is in the list and whether more pages follow.""" pageInfo: PageInfo! """ Number of items matching the filter on all pages together, not only on this one. """ totalCount: Int! } """ An element of a product: a part made separately, for example the cover or the inside pages of a book, with the operations that make it. """ type Element { """ Identifier of the element type (an entry of `referenceData(type: ELEMENT_TYPE)`); null when not set. """ elementTypeId: ID """Identifier of the element (UUID).""" id: ID! """Name of the element, for example `Okladka`.""" name: String! """ Operations that make the element, in production order. An empty list (never null) when the element has none. """ operations: [Operation!] """ The product the element belongs to. Always set for an API key; null in the app for a person who may not see the product. """ product: Product """Identifier of the product the element belongs to.""" productId: ID! """ How far production of the element has got: the roll-up of its operations. """ production: ProductionProgress! """ Position of the element within the product; only the order of values matters. Null for an element saved without a position (older data); such elements come last. """ sequenceOrder: Int """ Technology of the element as the calculation set it: sheet formats, ups, colours, plates and sheets. Null on an element without one: entered by hand, created through the API, or taken over from the print shop's previous system. An element taken over from the previous system describes the format and the paper in `Operation.comments`, under labels as the previous system spelled them; the same comments complete the technology copied from a calculation taken over from the previous system, which may lack some values. """ spec: ElementSpec } """ Technology of an element of an order, copied from the calculation it was priced with: sheet formats, ups, colours, plates and sheets. Nobody edits the copy (a product moved to another calculation gets new elements with their own). What the calculation left to the dictionary of sheet formats is worked out from the dictionary as it is when read: the millimetres of a sheet the calculation gave only by its format, and an automatic `purchaseToPrintDivisor`. A change of a format in the dictionary may change them without moving `Order.updatedAt`. """ type ElementSpec { """ Process colours on the back, for example 0 for a sheet printed on one side; null when not set. """ colorsBack: Int """Process colours on the front, for example 4; null when not set.""" colorsFront: Int """Identifier of the element.""" elementId: ID! """Printing forms the calculation counted; null when not counted.""" formsCount: Int """ True for the main element of the product: the operations on the whole product (binding, trimming, packing) are counted on it. """ isMain: Boolean! """Notes of the estimator about the technology; null when empty.""" notesTechnology: String """Pages of the element; null when it is not paged.""" pages: Int """ Spot (Pantone) colours on the back; 0 for none, null when the calculation did not record it. """ pantoneBack: Int """ Spot (Pantone) colours on the front; 0 for none, null when the calculation did not record it. """ pantoneFront: Int """Grammage of the paper in grams per square metre; null when none.""" paperGrammage: Float """Name of the paper as the calculation recorded it; null when none.""" paperName: String """ Type of the paper as the calculation recorded it: usually a value of `PaperType` (for example `COATED_MATTE`), free text in a calculation taken over from the previous system; null when none. """ paperType: String """ Weight of the paper of the whole run in kilograms; null when not counted. """ paperWeightKg: Float """Passes of the sheets through the press; null when not counted.""" passes: Int """ Pieces of this element in one product, for example 2 for an element used twice. """ piecesPerProduct: Float! """Plate sets the calculation counted; null when not counted.""" plateSets: Int """Printing plates the calculation counted; null when not counted.""" platesCount: Int """ Identifier of the press the calculation planned the printing on (an entry of `machines`); null when not chosen. Production uses the machine of the operation, `Operation.machineId`. """ pressMachineId: ID """ Identifier of the print sheet format (an entry of `referenceData(type: SHEET_FORMAT)`); null for a custom size given only in millimetres. """ printFormatId: ID """ Height of the print sheet in millimetres as the calculation recorded it; when it recorded only the format, the height of that format in the dictionary when read. Null only when the calculation gave no print sheet. """ printHeightMm: Float """ How the sheet is printed: one side, sheetwise or work-and-turn; null when not set. """ printScheme: PrintScheme """Print sheets with waste; null when not counted.""" printSheetsGross: Int """Print sheets without waste; null when not counted.""" printSheetsNet: Int """ Width of the print sheet in millimetres as the calculation recorded it; when it recorded only the format, the width of that format in the dictionary when read. Null only when the calculation gave no print sheet. """ printWidthMm: Float """ Identifier of the purchase sheet format, the sheet bought from the supplier (an entry of `referenceData(type: SHEET_FORMAT)`); null for a custom size given only in millimetres. """ purchaseFormatId: ID """ Height of the purchase sheet in millimetres as the calculation recorded it; when it recorded only the format, the height of that format in the dictionary when read. Null only when the calculation gave no purchase sheet. """ purchaseHeightMm: Float """Purchase sheets to buy; null when not counted.""" purchaseSheets: Int """ Print sheets cut from one purchase sheet: the divisor stated in the calculation, else the automatic one, worked out when read from the sheet formats of the dictionary (the divisor of the print format when it is cut from the purchase format, else the geometry of both sheets), so a change of a format may change it. Null only without sheet sizes. """ purchaseToPrintDivisor: Int """ Width of the purchase sheet in millimetres as the calculation recorded it; when it recorded only the format, the width of that format in the dictionary when read. Null only when the calculation gave no purchase sheet. """ purchaseWidthMm: Float """Spine width in millimetres, for a bound product; null otherwise.""" spineMm: Float """Net height of one piece in millimetres; null when not set.""" unitHeightMm: Float """Net width of one piece in millimetres; null when not set.""" unitWidthMm: Float """Pieces across one print sheet; null when not set.""" upsColumns: Int """Pieces on one print sheet (ups); null when not set.""" upsPerSheet: Int """Pieces down one print sheet; null when not set.""" upsRows: Int """Waste of the printing in sheets; null when not counted.""" wasteSheets: Int } """ A file stored in Prynt and attached to a record, for example a print file of a product. """ type File { """When the upload was started.""" createdAt: DateTime! """ Signed URL to download the file, valid for a limited time (one hour by default): request the field again for a fresh one. Needs no API key (do not send one). Set for every file on `Order.files` and `Product.files`; null only for a file whose content is not stored. """ downloadUrl: String """Identifier of the record the file is attached to.""" entityId: ID! """Kind of record the file is attached to.""" entityType: FileEntityType! """Identifier of the file (UUID).""" id: ID! """Media type of the file, for example `application/pdf`.""" mimeType: String! """ File name as uploaded, without characters unsafe for storage (such as `/` or `:`). """ originalFilename: String! """ Identifier of the first version of the file; null for the first version itself. """ parentFileId: ID """ Signed URL of a larger WebP preview (800 px wide by default), valid like `downloadUrl`. Null until Prynt has made it, and for files it cannot preview. """ previewUrl: String """ Size in bytes, as a decimal string (files may exceed the range of a GraphQL Int). Measured in storage once the upload completes. """ sizeBytes: String! """ Signed URL of a small WebP thumbnail (200 px wide by default), valid like `downloadUrl`. Null until Prynt has made it, and for files it cannot preview. """ thumbnailUrl: String """ When the file record last changed, for example when its upload completed. """ updatedAt: DateTime! """Where the upload of the file stands.""" uploadStatus: FileUploadStatus! """ Prepress verdict on a print file of a product; null for files outside the product file check (for example files of an order). """ verificationStatus: FileVerificationStatus """Version of the file, from 1 for the first upload.""" versionNumber: Int! } """Kind of record a file is attached to.""" enum FileEntityType { """An order.""" ORDER """ A product of an order: its print files, checked in prepress while the product is not yet in production. """ PRODUCT """A sales invoice of a product of an order (`ProductInvoice.file`).""" PRODUCT_INVOICE """A purchase invoice from a supplier (`PurchaseInvoice.file`).""" PURCHASE_INVOICE } """Where the upload of a file stands.""" enum FileUploadStatus { """Uploaded: the file is available.""" COMPLETED """ Not completed in time or rejected: the file is not available; upload it again. """ FAILED """Started: waiting for the content and for `completeFileUpload`.""" PENDING """A large file is being uploaded in parts.""" UPLOADING } """Prepress verdict on a print file of a product.""" enum FileVerificationStatus { """Accepted for print.""" ACCEPTED """Prepress asked for changes.""" CHANGES_REQUESTED """Waiting for prepress to check the file.""" TO_CHECK } """ A foil kept in the warehouse in rolls (for laminating or stamping), cut into sheets when issued. """ type Foil { """Barcode on the foil's labels; null when it has none.""" barcode: String """What the foil is used for.""" category: FoilCategory! """Warehouse code of the foil, unique and given by Prynt, e.g. "FO-1".""" code: String! """When the foil was added.""" createdAt: DateTime! """Currency of the purchase price, a 3-letter code (e.g. PLN).""" currency: String! """Identifier of the foil.""" id: ID! """When foil was last issued from stock; null when never.""" lastIssuedAt: DateTime """ Meters of foil on one roll (up to 3 decimals): what converts sheets issued (`WithdrawFoilInput`) to rolls of stock. Zero when not set. """ metersPerRoll: Float! """ Minimum stock level in rolls: below it the foil counts as low on stock; null when not set. """ minimumStock: Float """Name of the foil, e.g. "Deprosa mat".""" name: String! """ Stock in rolls (up to 2 decimals; part of a roll counts), never below zero. Every receipt, issue and stock-take adjustment changes it and is listed in `stockMovements`. """ numberOfRolls: Float! """ Purchase price per square meter, in `currency` (up to 4 decimals); null when not set. """ pricePerM2: Float """ The preferred supplier of the foil (`Query.supplier`); null when not set. """ supplierId: ID """Finish of the foil; null when not set.""" type: FoilType """ When the foil or its stock last changed: an edit of the card that changes a field (saving the same values changes nothing), and every receipt, issue, purchase-order delivery and stock-take adjustment. What `updatedFrom` and the `UPDATED_AT` sort read. """ updatedAt: DateTime! """Roll width in millimeters (up to 2 decimals); null when not set.""" widthMm: Float } """What a foil is used for.""" enum FoilCategory { """Cold foil stamping.""" COLD_STAMPING """Digital foiling (toner-based).""" DIGITAL_FOIL """Hot foil stamping.""" HOT_STAMPING """Laminating sheets.""" LAMINATION """Any other use.""" OTHER } """ Conditions on foils: a foil is listed when it meets every condition given. Omitted conditions do not filter. """ input FoilFilterInput { """ The foil with exactly this barcode (case-insensitive), e.g. read by a scanner. """ barcode: String """Foils used for this.""" category: FoilCategory """Foils whose code contains this text (case-insensitive).""" code: String """Foils whose name contains this text (case-insensitive).""" nameContains: String """Foils with at most this many rolls in stock.""" numberOfRollsMax: Float """ Foils with at least this many rolls in stock (`numberOfRolls`); part of a roll counts. """ numberOfRollsMin: Float """ Foils whose preferred supplier has this identifier (`Foil.supplierId`). """ supplierId: ID """Foils of this finish.""" type: FoilType """ Only foils that changed at or after this moment (inclusive), as `Foil.updatedAt` shows it. For incremental sync: pass the latest `updatedAt` you have seen, minus a few minutes, and sort by `UPDATED_AT` ascending. Null or left out: no bound (the first run of a sync reads every one). """ updatedFrom: DateTime } """ What to sort foils by. Foils with equal values keep a fixed order (by identifier), so pages do not overlap. """ enum FoilSortField { """What the foil is used for (`category`).""" CATEGORY """Warehouse code of the foil.""" CODE """When the foil was added.""" CREATED_AT """When foil was last issued from stock.""" LAST_ISSUED_AT """Meters of foil on one roll.""" METERS_PER_ROLL """Name of the foil.""" NAME """Stock in rolls.""" NUMBER_OF_ROLLS """Finish of the foil (`type`).""" TYPE """ When the record last changed (`Foil.updatedAt`). Ascending, with `updatedFrom`, for incremental sync. """ UPDATED_AT """Roll width in millimeters.""" WIDTH_MM } """How to sort foils.""" input FoilSortInput { """Ascending or descending.""" direction: SortDirection! """What to sort by.""" field: FoilSortField! } """Finish of a foil.""" enum FoilType { """Scratch-resistant.""" ANTI_SCRATCH """Gloss.""" BLYSK """Colored.""" COLORED """Gold.""" GOLD """Holographic.""" HOLOGRAPHIC """Matte.""" MAT """Any other finish.""" OTHER """Pigment (color) foil.""" PIGMENT """Silver.""" SILVER """Soft-touch.""" SOFT """Special effect.""" SPECIAL """Textured.""" STRUCTURAL """Transparent.""" TRANSPARENT } """One page of foils and the size of the whole list.""" type FoilsResult { """Foils on this page, in the requested sort order.""" items: [Foil!]! """Where this page is in the list and whether more pages follow.""" pageInfo: PageInfo! """ Number of items matching the filter on all pages together, not only on this one. """ totalCount: Int! } """ A file to upload: its name, type and exact size, and the record to attach it to. """ input InitiateUploadInput { """ Identifier of the order or product to attach the file to; it must exist, and its order must not be archived. """ entityId: ID! """ Kind of record to attach the file to: an `ORDER` or a `PRODUCT` of an order (a print file belongs to its `PRODUCT`). Invoice documents (`PRODUCT_INVOICE`, `PURCHASE_INVOICE`) are read-only for an API key: an upload to them is refused. """ entityType: FileEntityType! """ File name to keep, for example `ulotka-a5.pdf` (up to 500 characters; characters unsafe for storage are removed). """ filename: String! """ Media type of the file, for example `application/pdf`. By default Prynt accepts print and office formats (PDF, PNG, JPEG, TIFF, WebP, SVG, PostScript, Illustrator, InDesign, Photoshop, ZIP, RAR, XLSX, DOCX, CSV); another type is refused. """ mimeType: String! """ Exact size of the file in bytes, at least 1 and at most 5 GB. The upload must send exactly this many bytes. """ sizeBytes: Float! } """ Where and how to send the file content: a single HTTP request to `uploadUrl`, then `completeFileUpload`. """ type InitiateUploadResult { """ When `uploadUrl` stops working, as an ISO 8601 date-time string. Start the upload again after that. """ expiresAt: String! """ Identifier of the new file; pass it to `completeFileUpload` after sending the content. """ fileId: ID! """HTTP method of the upload request, for example `PUT`.""" method: String! """ Headers the upload request must carry, as a JSON object in a string (for example `{"Content-Type":"application/pdf"}`); null when none are required. """ requiredHeaders: String """ Signed URL to send the file content to. Valid until `expiresAt`; needs no API key (do not send one). """ uploadUrl: String! } """ A machine of the print shop (a press, a cutter, a laminator…): where operations and tasks run. """ type Machine { """Identifier of the machine (UUID).""" id: ID! """ False when the print shop decommissioned the machine: older operations and tasks may still point at it. """ isActive: Boolean! """Manufacturer of the machine; null when not recorded.""" manufacturer: String """Model of the machine; null when not recorded.""" model: String """ Name of the machine in the print shop, unique, for example `Heidelberg SM 74`. """ name: String! } """ Conditions on machines: a machine is listed when it meets every condition given. Omitted conditions do not filter. """ input MachineFilterInput { """True: machines in use only; false: decommissioned ones only.""" isActive: Boolean """Machines whose name contains this text (case-insensitive).""" name: String } """ What to sort machines by. Machines with equal values keep a fixed order (by identifier), so pages do not overlap. """ enum MachineSortField { """Name of the machine.""" NAME } """How to sort machines.""" input MachineSortInput { """Ascending or descending.""" direction: SortDirection! """What to sort by.""" field: MachineSortField! } """One page of machines and the size of the whole list.""" type MachinesResult { """Machines on this page, in the requested sort order.""" items: [Machine!]! """Where this page is in the list and whether more pages follow.""" pageInfo: PageInfo! """ Number of items matching the filter on all pages together, not only on this one. """ totalCount: Int! } """Kind of material a supplier delivers.""" enum MaterialType { """Foil, stocked in rolls (`Query.foil`).""" FOIL """Anything else, kept outside the warehouse stock.""" OTHER """Paint, stocked in grams (`Query.paint`).""" PAINT """Paper, stocked in sheets (`Query.paper`).""" PAPER } """One page of matrices and the size of the whole list.""" type MatricesResult { """Matrices on this page, in the requested sort order.""" items: [Matrix!]! """Where this page is in the list and whether more pages follow.""" pageInfo: PageInfo! """ Number of items matching the filter on all pages together, not only on this one. """ totalCount: Int! } """ A matrix (embossing or stamping die) kept in the warehouse: a tool, counted by uses, not by stock. """ type Matrix { """When the matrix was archived (taken out of use); null while in use.""" archivedAt: DateTime """ The client the matrix was made for (`Query.client`, with `clients:read`); null when none. """ clientId: ID """Warehouse code of the matrix, unique, e.g. "MT12" or "HS5".""" code: String! """When the matrix was added.""" createdAt: DateTime! """Description of the matrix; null when none.""" description: String """How many times the matrix was used (editions made with it).""" editionCount: Int! """Height in millimeters (up to 2 decimals); null when not set.""" heightMm: Float """Identifier of the matrix.""" id: ID! """When the matrix was last used; null when never.""" lastIssuedAt: DateTime """Warehouse location; null when not set.""" location: String """Whether the matrix is marked for disposal.""" markedForDeletion: Boolean! """What the matrix is made of; null when not set.""" material: MatrixMaterial """What the matrix is for.""" matrixType: MatrixType! """Name of the matrix.""" name: String! """Whether the matrix needs to be remade.""" needsRegeneration: Boolean! """ Number of the order the matrix was first made for, as text; null when not recorded. """ orderNumber: String """ When the matrix last changed: an edit that changes a field, a use, archiving or restoring (saving the same values, or archiving it again, changes nothing). What `updatedFrom` and the `UPDATED_AT` sort read. """ updatedAt: DateTime! """Width in millimeters (up to 2 decimals); null when not set.""" widthMm: Float """Working temperature in degrees Celsius; null when not set.""" workingTemperature: Int } """ Conditions on matrices: a matrix is listed when it meets every condition given. Omitted conditions do not filter. """ input MatrixFilterInput { """Matrices made for this client.""" clientId: ID """Matrices whose code contains this text (case-insensitive).""" code: String """ True: only archived matrices; false: only matrices in use. Left out: matrices in use, but with `updatedFrom` archived ones too, so a sync sees a matrix being archived (`archivedAt`). """ isArchived: Boolean """ Matrices whose warehouse location contains this text (case-insensitive). """ location: String """Matrices that are (true) or are not (false) marked for disposal.""" markedForDeletion: Boolean """Matrices made of this material.""" material: MatrixMaterial """Matrices for this kind of work.""" matrixType: MatrixType """Matrices whose name contains this text (case-insensitive).""" nameContains: String """Matrices that do (true) or do not (false) need remaking.""" needsRegeneration: Boolean """ Only matrices that changed at or after this moment (inclusive), as `Matrix.updatedAt` shows it. For incremental sync: pass the latest `updatedAt` you have seen, minus a few minutes, and sort by `UPDATED_AT` ascending. Null or left out: no bound (the first run of a sync reads every one). """ updatedFrom: DateTime } """What a matrix is made of.""" enum MatrixMaterial { """Brass.""" BRASS """Copper.""" COPPER """Magnesium.""" MAGNESIUM """Any other material.""" OTHER """Silicone.""" SILICONE """Steel.""" STEEL } """ What to sort matrices by. Matrices with equal values keep a fixed order (by identifier), so pages do not overlap. """ enum MatrixSortField { """Identifier of the client the matrix was made for.""" CLIENT """Warehouse code of the matrix.""" CODE """When the matrix was added.""" CREATED_AT """How many times the matrix was used.""" EDITION_COUNT """When the matrix was last used.""" LAST_ISSUED_AT """What the matrix is made of (`material`).""" MATERIAL """What the matrix is for (`matrixType`).""" MATRIX_TYPE """Name of the matrix.""" NAME """ When the record last changed (`Matrix.updatedAt`). Ascending, with `updatedFrom`, for incremental sync. """ UPDATED_AT } """How to sort matrices.""" input MatrixSortInput { """Ascending or descending.""" direction: SortDirection! """What to sort by.""" field: MatrixSortField! } """What a matrix is for.""" enum MatrixType { """Blind embossing (without foil or ink).""" BLIND_EMBOSSING """Embossing.""" EMBOSSING """Hot foil stamping.""" HOT_STAMPING """Scoring (creasing).""" SCORING """Spot UV varnish.""" SPOT_UV } type Mutation { """ Adds an additional cost (for example design work) to an order or to one of its products. Refused for an archived order. """ addAdditionalCost( """The cost and the order or product it is charged on.""" input: AddAdditionalCostInput! ): AdditionalCost! """ Gives a client a tag from `clientTags`. Always true; giving a tag the client already has changes nothing. """ assignClientTag( """Identifier of the client.""" clientId: ID! """Identifier of the tag.""" tagId: ID! ): Boolean! """ Confirms that the content of a file started with `initiateFileUpload` was sent. Prynt checks the stored size, marks the file completed and attaches it to its record. A file of a product still in prepress (`NO_FILES`, `FILES_TO_CHECK`, `WAITING_FOR_ADMIN_RESPONSE`, `WAITING_FOR_CLIENT_RESPONSE`, `FILES_ACCEPTED`) moves the product to `FILES_TO_CHECK` and its files back to checking: a new file on a product with accepted files cancels the acceptance. A product already in production or further keeps its status. Only the integration that started the upload may complete it, once. """ completeFileUpload( """The file whose upload to complete.""" input: CompleteUploadInput! ): File! """ Adds a client — with its headquarters address and, for a person, a self contact — and, from an integration, the integration's own reference (`externalRef`). The print shop completes the commercial terms (credit limit, discount, payment term and method, invoicing billing entity, currency) and any block in Prynt. """ createClient( """The new client.""" input: CreateClientInput! ): Client! """ Adds an address to a client. With `isDefault`, it becomes the default address of its type and the previous default one stops being it. """ createClientAddress( """Identifier of the client.""" clientId: ID! """The new address.""" input: ClientAddressInput! ): ClientAddress! """ Adds a contact person to a client. It needs at least a name, an e-mail or a phone. With `isPrimary`, it becomes the primary contact instead of the previous one. """ createClientContact( """Identifier of the client.""" clientId: ID! """The new contact person.""" input: ClientContactInput! ): ClientContact! """ Writes a CRM note about a client — a call, a meeting, an e-mail — with the caller as its author. A note from an integration is shared with the staff. """ createClientNote( """The new note.""" input: CreateClientNoteInput! ): ClientNote! """ Creates an order with its products (and their elements and operations), contact, delivery addresses, billing details and additional costs. The order gets its number and starts as `CREATED`. """ createOrder( """The new order.""" input: CreateOrderInput! ): Order! """ Records a payment received for an order, in the order currency. Does not change `Order.paymentStatus`: set it with `updateOrder` when the order is paid. Refused for an archived order. """ createOrderPayment( """The payment and the order it is for.""" input: CreateOrderPaymentInput! ): OrderPayment! """ Adds a product to an existing order that is not archived. It starts as `NO_FILES`, before any print file. Elements and operations are entered with the order (`createOrder`) or by the print shop. """ createProduct( """The new product.""" input: CreateProductInput! ): Product! """ Adds a purchase order (status DRAFT) with its items and, from an integration, the integration's own reference (`externalRef`). From an API key the supplier must be active (`Supplier.isActive`). Not idempotent: look the order up by `externalRef` first, and retry with `Idempotency-Key`. """ createPurchaseOrder( """The new purchase order.""" input: CreatePurchaseOrderInput! ): PurchaseOrder! """ Adds a supplier. Not idempotent: look the supplier up first (e.g. by `nip` or `code`), and retry with `Idempotency-Key`. """ createSupplier( """The new supplier.""" input: CreateSupplierInput! ): Supplier! """ Starts uploading a file to an order or a product: records the file as pending and returns a signed URL to send its content to. Then send the content in one request and call `completeFileUpload`. An upload not completed within an hour may be dropped (its file becomes `FAILED`). """ initiateFileUpload( """The file to upload and the record to attach it to.""" input: InitiateUploadInput! ): InitiateUploadResult! """ Receives foil into stock outside purchase orders (for a delivery ordered in Prynt use `receivePurchaseOrder`): books a movement — with the price, supplier and delivery document given, kept on it as they were — and raises the stock in rolls. The price, currency and supplier on the foil card do not change. Not idempotent: retry with `Idempotency-Key` (one key per receipt written, not per delivery document: one document often holds several lines of one material). Answers with the foil after the receipt. """ receiveFoil( """Identifier of the foil.""" id: ID! """The rolls received.""" input: ReceiveFoilInput! ): Foil! """ Receives paint into stock outside purchase orders (for a delivery ordered in Prynt use `receivePurchaseOrder`): books a movement — with the price, supplier and delivery document given, kept on it as they were — and raises the stock. The price, currency and supplier on the paint card do not change. Not idempotent: retry with `Idempotency-Key` (one key per receipt written, not per delivery document: one document often holds several lines of one material). Answers with the paint after the receipt. """ receivePaint( """Identifier of the paint.""" id: ID! """The grams received.""" input: ReceivePaintInput! ): Paint! """ Receives paper into stock outside purchase orders (for a delivery ordered in Prynt use `receivePurchaseOrder`): books a movement — with the price, supplier and delivery document given, kept on it as they were — and raises the stock. The price, currency and supplier on the paper card do not change. Refused for a paper kept for pricing only (`Paper.isStock` false, PAPER_PRICING_ONLY): the print shop does not track its stock. Not idempotent: retry with `Idempotency-Key` (one key per receipt written, not per delivery document: one document often holds several lines of one material). Answers with the paper after the receipt. """ receivePaper( """Identifier of the paper.""" id: ID! """The sheets received.""" input: ReceivePaperInput! ): Paper! """ Receives a delivery against a SENT, CONFIRMED or PARTIALLY_RECEIVED purchase order (another status: PURCHASE_ORDER_NOT_RECEIVABLE): each item's received quantity grows, never above what was ordered (PURCHASE_ORDER_OVER_RECEIVED), and the stock of its material rises by the delivery converted to the stock unit, with a RECEIPT in `stockMovements` linked to the order — unless the stock's precision rounds the delivery away (a few meters of a long foil roll), when only the received quantity grows. Each movement records the item's unit price and unit, the order's currency and supplier, and the delivery's `deliveredAt` and `documentNumber`. A delivery of a paper kept for pricing only (`Paper.isStock` false) is refused (PAPER_PRICING_ONLY). The status becomes PARTIALLY_RECEIVED or, once every item arrived in full, RECEIVED. Not idempotent: retry with `Idempotency-Key`. Answers with the order. """ receivePurchaseOrder( """Identifier of the purchase order.""" id: ID! """What arrived.""" input: ReceivePurchaseOrderInput! ): PurchaseOrder! """ Takes a tag from a client (the tag itself stays). Always true; taking a tag the client does not have changes nothing. """ removeClientTag( """Identifier of the client.""" clientId: ID! """Identifier of the tag.""" tagId: ID! ): Boolean! """ Changes an additional cost of an order; refused for an archived order. Sending the same values again changes nothing, not even `Order.updatedAt`. """ updateAdditionalCost( """Identifier of the additional cost to change.""" id: ID! """What to change.""" input: UpdateAdditionalCostInput! ): AdditionalCost! """ Changes a client: a field left out keeps its value, null clears a field that may be empty. `Client.updatedAt` moves only when something really changed: the same values sent again leave it as it was. A client the print shop deactivated (`isActive: false`) takes no change from an API key, nor do its contacts, addresses, notes and tags. """ updateClient( """Identifier of the client to change.""" id: ID! """ What to change: fields left out keep their values. An explicit null is refused unless the field says otherwise. """ input: UpdateClientInput! ): Client! """ Changes an address of a client: a field left out keeps its value, null clears an optional field. The same values sent again change nothing. """ updateClientAddress( """Identifier of the address to change.""" addressId: ID! """What to change.""" input: UpdateClientAddressInput! ): ClientAddress! """ Changes a contact person: a field left out keeps its value, null clears a text field. The contact must keep a name, an e-mail or a phone. The same values sent again change nothing. """ updateClientContact( """Identifier of the contact to change.""" contactId: ID! """What to change.""" input: ClientContactInput! ): ClientContact! """ Changes a note. Only its author may: an integration changes the notes it wrote. A field left out keeps its value; the same values sent again change nothing. """ updateClientNote( """Identifier of the note.""" id: ID! """What to change.""" input: UpdateClientNoteInput! ): ClientNote! """ Changes one operation of an element: fields left out keep their values, null clears only the fields that say so. The order must not be archived. `machineId` cannot change while a production task of the operation is planned, running or paused (`OPERATION_IN_PRODUCTION`): finish or cancel the task in Prynt first; completed tasks keep the machine they ran on, and the next task takes the new one. An API key may move an operation only to a machine in use (`MACHINE_INACTIVE`) with a default task type (`MACHINE_NO_DEFAULT_TASK_TYPE`). A new machine takes the operation off the pinned top of the queue of its old machine. A new `timePerUnitSeconds` replaces the machine time the calculation estimated (setup and run) with `timePerUnitSeconds` times `quantity`; a new `quantity` alone keeps the setup of the calculation and counts its run for the new quantity. A `quantity` at or below `quantityCompleted` makes the operation completed. Sending the same values again changes nothing, not even `Operation.updatedAt` or `Order.updatedAt` (`price` and `quantity` are compared after rounding to 2 and 3 decimal places), so a retry is safe without `Idempotency-Key`. """ updateOperation( """Identifier of the operation to change.""" id: ID! """ What to change: fields left out keep their values. An explicit null is refused unless the field says otherwise. """ input: UpdateOperationInput! ): Operation! """ Changes an order: its fields, status, contact, delivery addresses or billing details. Products are added and changed with `createProduct` and `updateProduct`. `Order.updatedAt` moves only when something really changed: the same values sent again leave it as it was. """ updateOrder( """Identifier of the order to change.""" id: ID! """ What to change: fields left out keep their values. An explicit null is refused unless the field says otherwise. """ input: UpdateOrderInput! ): Order! """ Changes a product: fields left out keep their values. The order must not be archived. Sending the same values again changes nothing, not even `Order.updatedAt`. """ updateProduct( """Identifier of the product to change.""" id: ID! """ What to change: fields left out keep their values. An explicit null is refused unless the field says otherwise. """ input: UpdateProductInput! ): Product! """ Changes a purchase order that is neither RECEIVED nor CANCELLED: a field left out keeps its value, `items` replaces the whole item list. Changes of the header and of items sent with their `id` are safe to repeat — the same values sent again leave the order and `PurchaseOrder.updatedAt` as they were — but an item without `id` is added on every call (the copy from an earlier call is removed), so retry with `Idempotency-Key`. From an API key a new supplier must be active. """ updatePurchaseOrder( """Identifier of the purchase order to change.""" id: ID! """ What to change: fields left out keep their values. An explicit null is refused unless the field says otherwise. """ input: UpdatePurchaseOrderInput! ): PurchaseOrder! """ Moves a purchase order to another status: DRAFT to SENT, SENT to CONFIRMED (or back), any status before RECEIVED to CANCELLED; any other move is refused. The current status again changes nothing, so a retry is safe. Answers with the order. """ updatePurchaseOrderStatus( """The order and its new status.""" input: UpdatePurchaseOrderStatusInput! ): PurchaseOrder! """ Changes a supplier: a field left out keeps its value, null clears an optional field. `Supplier.updatedAt` moves only when something really changed: the same values sent again leave it as it was. """ updateSupplier( """Identifier of the supplier to change.""" id: ID! """ What to change: fields left out keep their values. An explicit null is refused unless the field says otherwise. """ input: UpdateSupplierInput! ): Supplier! """ Issues foil from stock (production, waste, a correction, a return to the supplier): books a movement and lowers the stock by the rolls the sheets take (sheets x sheet length / `Foil.metersPerRoll`). Refused when it takes more than the stock (STOCK_INSUFFICIENT) or when the foil has no meters per roll (STOCK_UNIT_NOT_CONVERTIBLE). Not idempotent: retry with `Idempotency-Key`. Answers with the foil after the issue. """ withdrawFoil( """Identifier of the foil.""" id: ID! """The sheets cut and what for.""" input: WithdrawFoilInput! ): Foil! """ Issues paint from stock (production, waste, a correction, a return to the supplier): books a movement and lowers the stock by the grams taken. Refused when it takes more than the stock (STOCK_INSUFFICIENT). Not idempotent: retry with `Idempotency-Key`. Answers with the paint after the issue. """ withdrawPaint( """Identifier of the paint.""" id: ID! """The grams taken and what for.""" input: WithdrawPaintInput! ): Paint! """ Issues paper from stock (production, waste, a correction, a return to the supplier): books a movement and lowers the stock by the sheets taken. Refused when it takes more than the stock (STOCK_INSUFFICIENT) and for a paper kept for pricing only (`Paper.isStock` false, PAPER_PRICING_ONLY). Issued for an order, it fulfils the order's reservations of this paper. Not idempotent: retry with `Idempotency-Key`. Answers with the paper after the issue. """ withdrawPaper( """Identifier of the paper.""" id: ID! """The sheets taken and what for.""" input: WithdrawPaperInput! ): Paper! } """ A production operation on an element, for example printing or laminating, done on one machine. """ type Operation { """ Identifier of the color profile (an entry of `referenceData(type: COLOR_PROFILE)`); null when not set. """ colorProfileId: ID """ Notes for production on the operation. An empty list when there are none. """ comments: [OperationComment!]! """What the operation is, in the print shop words; null when empty.""" description: String """ The element the operation makes. Always set for an API key; null in the app for a person who may not see the product. """ element: Element """Identifier of the element the operation belongs to.""" elementId: ID! """ When production completed the operation; null while it is not completed. """ endedAt: DateTime """ Identifier of the finishing type (an entry of `referenceData(type: FINISHING_TYPE)`); null when not set. """ finishingTypeId: ID """Identifier of the operation (UUID).""" id: ID! """Identifier of the machine that does the operation.""" machineId: ID! """ Identifier of the operation type (an entry of `referenceData(type: OPERATION_TYPE)`); null when not set. """ operationTypeId: ID """ The order the operation belongs to. Always set for an API key; null in the app for a person who may not see the order. """ order: Order """ Identifier of the order the operation belongs to (through its element and product). """ orderId: ID! """ The operation right before this one in its element (`previousOperationId`). Whether the operation may start depends on EVERY earlier operation of the element, not only this one: read `readyToStart`. """ previousOperation: Operation """ Identifier of the operation that precedes this one in the production order of its element (the nearest lower `sequenceOrder`); null for the first operation of the element and for an operation without a position. """ previousOperationId: ID """ Net price of the whole operation (its full `quantity`, not per unit), in the order currency. """ price: Float! """ The product the operation belongs to. Always set for an API key; null in the app for a person who may not see the product. """ product: Product """ Identifier of the product the operation belongs to (through its element). """ productId: ID! """ Where production of the operation stands: COMPLETED once `endedAt` is set or the whole `quantity` is done, IN_PROGRESS while its task runs, PAUSED when its task is paused or part of the quantity is done, NOT_STARTED otherwise. """ productionStatus: ProductionStatus! """How many units the operation processes, in `unit`.""" quantity: Float! """ How many units production has completed so far, in `unit` (0 before production starts). """ quantityCompleted: Float! """ Whether the shop floor may take the operation up now, by the same rule the machine queue in Prynt uses: every earlier operation of its element (a lower `sequenceOrder`) is finished, that is completed (`endedAt`) with its whole `quantity` done. Material positions (paper, board or a tool issued from the warehouse, and any operation on a warehouse machine) never hold the next ones back; an operation without a position is always ready. It can be false while the previous operation has `productionStatus` COMPLETED: completed without the whole quantity. It changes when ANOTHER operation of the element is finished, without moving this operation's `updatedAt`; `Order.updatedAt` moves then, so sync `orders(updatedFrom)` as well. """ readyToStart: Boolean! """ Position of the operation within its element; only the order of values matters: the first operation has the lowest value (0 or 1, depending on how the order was made). Null for an operation saved without a position (older data); such operations come last. """ sequenceOrder: Int """ Production tasks of the operation, oldest first: one for each time the shop floor took it up (a partly done operation gets a new task). An empty list (never null) before production starts. """ tasks: [Task!]! """ Estimated machine time per unit of `quantity`, in seconds; the whole operation takes `timePerUnitSeconds * quantity`. """ timePerUnitSeconds: Int! """Unit of `quantity` and `quantityCompleted`.""" unit: Unit! """ When the operation last changed: its own fields (quantities, time, machine, position, completion) or its production tasks (one created, started, paused, resumed, completed or cancelled). Changes of the order, product or element it belongs to move `Order.updatedAt`, not this. Writing back the same values (a technology saved unchanged in Prynt) does not move it. Filter on it with `updatedFrom` to fetch only what changed since your last sync. Operations saved before 0.33.0 carry the moment of that upgrade. """ updatedAt: DateTime! } """ A note for production on an operation, as a label and a value (for example `Papier`: `Kreda 130 g`). """ type OperationComment { """Identifier of the note (UUID).""" id: ID! """True when the note is marked important for production.""" isImportant: Boolean! """What the note is about, for example `Papier` or `Uwagi`.""" label: String! """Identifier of the operation the note belongs to.""" operationId: ID! """Text of the note.""" value: String! } """ Conditions on operations: an operation is listed when it meets every condition given. Omitted conditions do not filter. """ input OperationFilterInput { """Operations of this element (`Operation.elementId`).""" elementId: ID """Operations done on this machine (`Operation.machineId`).""" machineId: ID """ True: only operations of archived orders; false: only operations of orders outside the archive. Omit for both. """ orderArchived: Boolean """ Operations of this order, of every product and element in it (`Operation.orderId`). """ orderId: ID """ Operations of orders in this status (`Order.status`). Ignored when `orderStatusIn` lists any status. """ orderStatus: OrderStatus """ Operations of orders in any of these statuses. An empty list filters nothing. """ orderStatusIn: [OrderStatus!] """Operations of the elements of this product (`Operation.productId`).""" productId: ID """ Operations whose production stands at this status, decided exactly as `Operation.productionStatus` is. It reads the state of production, so an API key filters by it with the production scope. Ignored when `productionStatusIn` lists any status. """ productionStatus: ProductionStatus """ Operations whose production stands at any of these statuses (see `productionStatus`). An empty list filters nothing. """ productionStatusIn: [ProductionStatus!] """ Only operations that changed at or after this moment (inclusive), as `Operation.updatedAt` shows it. For incremental sync: pass the latest `updatedAt` you have seen, minus a few minutes, and sort by `UPDATED_AT` ascending. Null or left out: no bound (the first run of a sync reads every one). """ updatedFrom: DateTime } """ What to sort operations by. Operations with equal values keep a fixed order (by identifier), so pages do not overlap. """ enum OperationSortField { """ Completion date of the operation's order (`Order.completionDate`), the natural order of work on a machine; operations of orders without one come last when ascending, first when descending. """ ORDER_COMPLETION_DATE """ When the record last changed (`Operation.updatedAt`). Ascending, with `updatedFrom`, for incremental sync. """ UPDATED_AT } """How to sort operations.""" input OperationSortInput { """Ascending or descending.""" direction: SortDirection! """What to sort by.""" field: OperationSortField! } """One page of operations and the size of the whole list.""" type OperationsResult { """Operations on this page, in the requested sort order.""" items: [Operation!]! """Where this page is in the list and whether more pages follow.""" pageInfo: PageInfo! """ Number of items matching the filter on all pages together, not only on this one. """ totalCount: Int! } """ A client's order at the print shop: the products to make, for whom, when and how to deliver them, and how the order is paid. """ type Order { """ Additional costs of the order, on the order itself and on its products, by position. An empty list (never null) when there are none. """ additionalCosts: [AdditionalCost!] """ Sum of the net amounts of all additional costs of the order, in the order currency. 0 (never null) when there are none. """ additionalCostsTotal: Float """ True when the order was moved to the archive (only received or cancelled orders). An archived order cannot be changed, and neither can anything inside it: its products, costs, payments and files. """ archived: Boolean! """ Identifier of the print shop's billing entity that invoices the order; null while none is chosen. """ billingEntityId: ID """Client associated with this order.""" client: Client """Identifier of the client (the print shop's customer) the order is for.""" clientId: ID! """ When the order is due to be completed (date and time). Null when not agreed yet. """ completionDate: DateTime """Person to contact about the order; null when none was entered.""" contact: OrderContact """When the order was created.""" createdAt: DateTime! """ Identifier of the order currency, in which the order's prices, costs and payments are expressed. Null on older orders, which are in the print shop's home currency. """ currencyId: ID """ Delivery addresses, in their order; empty for pickup or before the address is known. """ deliveries: [OrderDelivery!] """ Order number people use in Prynt and on documents, for example `1084/2026`. Unique; Prynt assigns it when the order is created. """ displayId: String! """ Exchange rate from the order currency to the print shop's home currency, fixed when the currency was set (1 for the home currency). Null on older orders. """ exchangeRate: Float """ Files attached to the order itself (files of its products are on `Product.files`), uploaded completely, newest first. An empty list (never null) when there are none. """ files: [File!] """Identifier of the order (UUID).""" id: ID! """Billing details to put on the invoice; null when none were entered.""" invoice: OrderInvoice """ True when `completionDate` is a strict deadline that must not move; false otherwise. Never null. """ isDeadline: Boolean """ Day by which the client should pay (UTC midnight of that day); null when not set. """ paymentDueDate: DateTime """How the client pays; null while not chosen.""" paymentMethod: PaymentMethod """Where payment of the order stands.""" paymentStatus: PaymentStatus! """ Payments received for the order, latest payment date first. An empty list (never null) when nothing was paid yet. """ payments: [OrderPayment!] """ How far production of the order has got: the roll-up of the operations of all its products and elements. """ production: ProductionProgress! """ Products of the order, by their number within the order. An empty list (never null) when the order has none yet. """ products: [Product!] """Channel the order came in through.""" source: OrderSource! """ Stage of the order. Prynt moves it forward with production; see `OrderStatus` for who sets each value. """ status: OrderStatus! """Number of packages the whole order ships in (0 when none).""" totalPackages: Int! """Number of pallets the whole order ships on (0 when none).""" totalPallets: Int! """How the order reaches the client.""" transportMethod: TransportMethod! """ Net price of transport in the order currency; null when not charged separately. """ transportPrice: Float """ When the order or anything inside it (products, their elements and operations, payments, additional costs, files, contact, deliveries, invoice data) last changed, including every status change of the production tasks of its operations (one created, started, paused, resumed, completed or cancelled). Writing back the same values does not move it. Filter on it with `updatedFrom` to fetch only what changed since your last sync. """ updatedAt: DateTime! } """An additional cost of a new order, for example design work.""" input OrderAdditionalCostInput { """Net amount of the cost in the order currency, 0 or more.""" amount: Float! """Kind of cost.""" category: AdditionalCostCategory """Longer description of the cost.""" description: String """ True (the default) to show the cost to the client, for example on the order summary. """ isClientVisible: Boolean """Name of the cost, as shown on documents.""" name: String! """ VAT rate as a fraction from 0 to 1, for example `0.23` for 23% (the default). """ taxRate: Float } """ The person to contact about an order, as saved on the order (a copy: later changes in the client's records do not change it). A text field is null when it was not given. """ type OrderContact { """E-mail address.""" email: String """First name.""" firstName: String """Identifier of the order contact (UUID).""" id: ID! """Last name.""" lastName: String """Name to show for the contact, usually first and last name.""" name: String """Identifier of the order.""" orderId: ID! """Phone number, as entered (up to 20 characters).""" phone: String """Role or position of the person, for example `Zakupy`.""" role: String """Where the contact data was copied from.""" source: OrderContactSource! } """ The person to contact about an order. Give at least a name, an e-mail or a phone number. """ input OrderContactInput { """E-mail address; must be a valid address.""" email: String """First name.""" firstName: String """Last name.""" lastName: String """ Name to show for the contact; without it Prynt joins `firstName` and `lastName`. Taken as sent only for a manually entered contact. """ name: String """Phone number, as you want it shown (up to 20 characters).""" phone: String """Role or position of the person, for example `Zakupy`.""" role: String } """Where the contact person of an order was copied from.""" enum OrderContactSource { """The client's own details.""" CLIENT """A contact person from the client's records.""" CLIENT_CONTACT """Entered on the order itself, as every contact sent through the API is.""" MANUAL } """ A delivery address of an order, with the packages and pallets that go there. A text field is null when it was not given. """ type OrderDelivery { """Apartment or suite number (up to 20 characters).""" apartmentNumber: String """Building number (up to 20 characters).""" buildingNumber: String """City.""" city: String """Company or recipient name.""" companyName: String """Person who receives the delivery.""" contactName: String """Country, as entered (for example `Polska` or `PL`).""" country: String """ Identifier of the delivery address (UUID). Changes whenever the order deliveries are saved again. """ id: ID! """Notes for the delivery, for example opening hours.""" notes: String """Identifier of the order.""" orderId: ID! """Packages going to this address; null when not split.""" packageCount: Int """Pallets going to this address; null when not split.""" palletCount: Int """Phone number for the courier (up to 15 characters).""" phone: String """Position of the address among the order deliveries, from 0.""" position: Int! """Street, without the building number.""" street: String """Postal code, for example `00-950` (up to 10 characters).""" zip: String } """ A delivery address of an order, with the packages and pallets that go there. """ input OrderDeliveryInput { """Apartment or suite number (up to 20 characters); null for none.""" apartmentNumber: String """Building number (up to 20 characters); null for none.""" buildingNumber: String """City.""" city: String """Company or recipient name.""" companyName: String """Person who receives the delivery.""" contactName: String """Country, for example `Polska` or `PL`.""" country: String """Notes for the delivery, for example opening hours.""" notes: String """Packages going to this address, 0 or more.""" packageCount: Int """Pallets going to this address, 0 or more.""" palletCount: Int """Phone number for the courier (up to 15 characters); null for none.""" phone: String """ Street, without the building number. The order can be sent only when `street`, `zip` and `city` are filled in. """ street: String """Postal code, for example `00-950`; null for none.""" zip: String } """ Conditions on orders: an order is listed when it meets every condition given. Omitted conditions do not filter. """ input OrderFilterInput { """ True: only archived orders; false: only orders outside the archive. Omit for both. """ archived: Boolean """Orders of the client with this identifier.""" clientId: ID """ Orders due to be completed at or after this moment (ISO 8601, like `createdFrom`). """ completionFrom: String """ Orders due to be completed at or before this moment (ISO 8601, like `createdTo`). """ completionTo: String """ Orders created at or after this moment: an ISO 8601 date-time, or a date meaning midnight UTC at its start. """ createdFrom: String """ Orders created at or before this moment (ISO 8601; a date alone means midnight UTC at its start, so it excludes the rest of that day). """ createdTo: String """ Orders whose number contains this text, ignoring case, for example `1084/` (up to 50 characters). """ displayId: String """ True: orders with a strict completion deadline; false: orders without one. """ isDeadline: Boolean """Orders with a payment due date on or after this day (ISO 8601 date).""" paymentDueDateFrom: String """Orders with a payment due date on or before this day (ISO 8601 date).""" paymentDueDateTo: String """Orders paid with this method. Ignored when `paymentMethodIn` is given.""" paymentMethod: PaymentMethod """Orders paid with any of these methods.""" paymentMethodIn: [PaymentMethod!] """ Orders with this payment status. Ignored when `paymentStatusIn` is given. """ paymentStatus: PaymentStatus """Orders with any of these payment statuses.""" paymentStatusIn: [PaymentStatus!] """ True: orders with a product that has a packing date; false: orders with a product without one. Omit for both. It holds for the same product as the other product conditions, so `false` together with a packing-date range lists nothing. """ productHasPackingDate: Boolean """ True: orders with an FSC-certified product; false: orders with a product that is not FSC-certified. """ productIsFsc: Boolean """ Orders with a product whose name contains this text, ignoring case (up to 200 characters). Product conditions together must hold for the same product. """ productNameContains: String """ Orders with a product planned to be packed at or after this moment (inclusive). Prynt stores a packing date as the start of that day in the print shop's time zone (Europe/Warsaw), possibly with a time of day: pass both bounds as date-times with an offset, e.g. `2026-10-30T00:00:00+01:00` (`+02:00` in summer time). Product conditions together must hold for the same product. """ productPackingDateFrom: DateTime """ Orders with a product planned to be packed at or before this moment (inclusive), e.g. `2026-10-30T23:59:59+01:00` for the whole day. """ productPackingDateTo: DateTime """ Orders with a product in this status. Ignored when `productStatusIn` is given. """ productStatus: ProductStatus """Orders with a product in any of these statuses.""" productStatusIn: [ProductStatus!] """Orders in this status. Ignored when `statusIn` is given.""" status: OrderStatus """Orders in any of these statuses.""" statusIn: [OrderStatus!] """ Orders with this transport method. Ignored when `transportMethodIn` is given. """ transportMethod: TransportMethod """Orders with any of these transport methods.""" transportMethodIn: [TransportMethod!] """ Orders that changed at or after this moment (inclusive), as `Order.updatedAt` shows it. For incremental sync: pass the latest `updatedAt` you have seen, minus a few minutes, and sort by `UPDATED_AT`. Null or left out: no bound (the first run of a sync reads every order). """ updatedFrom: DateTime } """ Billing details of an order: who the invoice is made out to. Not an invoice document. A text field is null when it was not given. """ type OrderInvoice { """City.""" city: String """Company name to put on the invoice.""" companyName: String """Country, as entered.""" country: String """Identifier of the billing details (UUID).""" id: ID! """Polish tax identification number (NIP), 10 digits.""" nip: String """Identifier of the order.""" orderId: ID! """Street with the building number.""" street: String """Postal code (up to 10 characters).""" zip: String } """Billing details of an order: who the invoice is made out to.""" input OrderInvoiceInput { """City.""" city: String """Company name to put on the invoice.""" companyName: String """Country.""" country: String """Polish tax identification number (NIP), 10 digits.""" nip: String """Street with the building number.""" street: String """Postal code (up to 10 characters).""" zip: String } """A payment received for an order, as recorded in Prynt.""" type OrderPayment { """Amount paid, in `currency`.""" amount: Float! """ `amount` converted to the print shop's home currency at `exchangeRate`, rounded to 0.01. Null only for payments recorded before Prynt kept home-currency amounts. """ amountHome: Float """When the payment was recorded in Prynt.""" createdAt: DateTime! """ ISO 4217 code of the payment currency, for example `PLN`: the order currency. """ currency: String! """ Exchange rate from `currency` to the print shop's home currency on the payment date (1 for the home currency). Null only for payments recorded before Prynt kept rates. """ exchangeRate: Float """Identifier of the payment (UUID).""" id: ID! """How the client paid.""" method: PaymentMethod! """Free-text note; null when none.""" notes: String """Identifier of the order the payment is for.""" orderId: ID! """ When the payment was received. Null only for older payments recorded without a date; a payment recorded through the API always has one. """ paidAt: DateTime """ Reference of the payment, for example the transfer title or a transaction number; null when none. """ reference: String } """ An element of a new product, for example the cover or the inside pages, with the operations that make it. """ input OrderProductElementInput { """ Identifier of the element type (an entry of `referenceData(type: ELEMENT_TYPE)`); optional, null or left out: none. """ elementTypeId: ID """Name of the element, for example `Okladka`.""" name: String! """Operations that make the element, in production order.""" operations: [OrderProductOperationInput!] } """ A product of a new order: what to make, how many, for what price, and its elements. """ input OrderProductInput { """ True when delivery must be announced to the recipient in advance (advice note). """ awizo: Boolean """Day the product is due (ISO 8601 date).""" dateDue: String """Description of the work for production (the job description).""" description: String """ Elements of the product (for example cover and inside pages) with their operations, in production order. """ elements: [OrderProductElementInput!] """ Where to get the files (for example a URL) when they are not uploaded to Prynt. """ fileLink: String """ How the client delivers the files when not uploading them to Prynt: `link`, `cloud`, `ftp`, `other` or `none`. """ fileType: String """True when the product is made of FSC-certified paper.""" isFsc: Boolean """True to hide the product (it stays part of the order).""" isHidden: Boolean """ISBN or ISSN of a publication (up to 32 characters).""" isbnIssn: String """Name of the product, for example `Ulotka A5`.""" name: String! """ True when the product is not to be invoiced; information for the office only. """ noInvoice: Boolean """Position of the product within the order, from 1; unique in the order.""" number: Int! """When the product is planned to be packed (ISO 8601).""" packingDate: String """ Net price of the whole product line (all `quantity` units together, not per unit), in the order currency, 0 or more. """ price: Float! """ Net markup added to `price`, as an amount in the order currency (not a percentage), 0 or more. """ priceMarkup: Float! """Print run: how many units to make, in `unit`, 0 or more.""" quantity: Float! """ VAT rate in percent, from 0 to 100: `23` for 23%. A value between 0 and 1 is refused as a fraction sent by mistake (`Product.taxRate` returns the rate as a fraction: `0.23`). """ taxRate: Float! """Unit of `quantity`.""" unit: Unit! """ Weight of the whole product line in kilograms, 0 or more (0 when unknown). """ weight: Float! } """A production operation of a new element, done on one machine.""" input OrderProductOperationInput { """ Identifier of the color profile (an entry of `referenceData(type: COLOR_PROFILE)`); optional, null or left out: none. """ colorProfileId: ID """What the operation is, in the print shop words.""" description: String """ Identifier of the finishing type (an entry of `referenceData(type: FINISHING_TYPE)`); optional, null or left out: none. """ finishingTypeId: ID """Identifier of the machine that does the operation.""" machineId: ID! """ Identifier of the operation type (an entry of `referenceData(type: OPERATION_TYPE)`); optional, null or left out: none. """ operationTypeId: ID """ Net price of the whole operation (its full `quantity`), in the order currency, 0 or more. """ price: Float! """How many units the operation processes, in `unit`.""" quantity: Float! """ Estimated machine time per unit of `quantity`, in whole seconds, 0 or more. """ timePerUnitSeconds: Int! """Unit of `quantity`.""" unit: Unit! } """ What to sort orders by. Orders with equal values keep a fixed order (by identifier), so pages do not overlap. """ enum OrderSortField { """ Completion date; orders without one come last when ascending, first when descending. """ COMPLETION_DATE """When the order was created.""" CREATED_AT """Order number, compared as text.""" DISPLAY_ID """ Payment due date; orders without one come last when ascending, first when descending. """ PAYMENT_DUE_DATE """ When the order or anything inside it last changed (`Order.updatedAt`). Ascending, with `updatedFrom`, for incremental sync. """ UPDATED_AT } """How to sort a list of orders.""" input OrderSortInput { """Ascending or descending.""" direction: SortDirection! """What to sort by.""" field: OrderSortField! } """Channel an order came in through.""" enum OrderSource { """Reserved for orders placed by the client.""" CLIENT """Created in Prynt: by staff or through the API.""" MANUAL """Reserved for orders from a web shop connector.""" WEBSHOP } """ Stage of an order. An order starts as `CREATED`; Prynt and the print shop move it forward. """ enum OrderStatus { """ Accepted: confirmed with the client. Needs a salesperson assigned to the order. """ ACCEPTED """Cancelled.""" CANCELLED """New: saved, not confirmed with the client yet.""" CREATED """ In production: Prynt sets it when the first production task of a product starts. """ IN_PRODUCTION """ Ready: Prynt sets it when every product is ready; the print shop may set it too. """ READY """Received: the client has the goods.""" RECEIVED """ Sent: handed over for delivery. Needs a complete delivery address, a transport method and, for a prepaid order, payment. """ SENT } """One page of orders and the size of the whole list.""" type OrdersResult { """Orders on this page, in the requested sort order.""" items: [Order!]! """Where this page is in the list and whether more pages follow.""" pageInfo: PageInfo! """ Number of items matching the filter on all pages together, not only on this one. """ totalCount: Int! } """Position of a page within a paginated list.""" type PageInfo { """ Number of this page, from 1. Always set on a numbered list (`page` and `pageSize`); null on a cursor list. """ currentPage: Int """ True when more items follow this page (for a numbered page: request `page + 1`). """ hasNextPage: Boolean! """True when items precede this page.""" hasPreviousPage: Boolean! """ Maximum number of items on a page, as used for this list. Always set on a numbered list; null on a cursor list. """ pageSize: Int """ Number of pages the whole list takes at this page size (0 for an empty list). Always set on a numbered list; null on a cursor list. """ totalPages: Int } """ Which page of a list to return. Pages are numbered from 1; without this argument the list returns its first page at the default size. """ input PaginationInput { """Page to return, from 1. Default 1.""" page: Int """ Maximum number of items on the page. Default 25; an API key may request 1 to 100. """ pageSize: Int } """A paint (ink) kept in the warehouse, with its stock in grams.""" type Paint { """Barcode on the paint's labels; null when it has none.""" barcode: String """Warehouse code of the paint, unique and given by Prynt, e.g. "F-1208".""" code: String! """ Color set on the paint card as a hex value, e.g. "#FF0000"; null when not set. Without it, the app shows the paint in the approximate Pantone swatch named like the paint (letter case, extra spaces and a leading "Pantone" ignored), or in no color when no swatch matches. The swatches: https://docs.prynt.pl/developers/pantone.json (also as CSV), the rule: https://docs.prynt.pl/developers/warehouse/. """ colorHex: String """When the paint was added.""" createdAt: DateTime! """Currency of the purchase price, a 3-letter code (e.g. PLN).""" currency: String! """Longer description of the paint; null when none.""" description: String """Manufacturer or brand, e.g. "Brancher"; null when not set.""" group: String """Identifier of the paint.""" id: ID! """When paint was last issued from stock; null when never.""" lastIssuedAt: DateTime """Warehouse location, e.g. "A-1-2"; null when not set.""" location: String """ Minimum stock level in grams: below it the paint counts as low on stock; null when not set. """ minimumStock: Float """Name of the paint, e.g. the Pantone name "1935 C".""" name: String! """Notes of the warehouse about the paint; null when none.""" notes: String """ Purchase price per kilogram, in `currency` (up to 4 decimals); null when not set. """ pricePerKg: Float """ Stock in grams (up to 3 decimals), never below zero. Every receipt, issue and stock-take adjustment changes it and is listed in `stockMovements`. """ quantityGrams: Float! """ The preferred supplier of the paint (`Query.supplier`); null when not set. """ supplierId: ID """ When the paint or its stock last changed: an edit of the card that changes a field (saving the same values changes nothing), and every receipt, issue, purchase-order delivery and stock-take adjustment. What `updatedFrom` and the `UPDATED_AT` sort read. """ updatedAt: DateTime! } """ Conditions on paints: a paint is listed when it meets every condition given. Omitted conditions do not filter. """ input PaintFilterInput { """ The paint with exactly this barcode (case-insensitive), e.g. read by a scanner. """ barcode: String """Paints whose code contains this text (case-insensitive).""" code: String """ Paints whose manufacturer or brand (`group`) contains this text (case-insensitive). """ group: String """Paints whose warehouse location contains this text (case-insensitive).""" location: String """Paints whose name contains this text (case-insensitive).""" nameContains: String """Paints with at most this many grams in stock.""" quantityGramsMax: Float """ Paints with at least this many grams in stock (`quantityGrams`, to 0.001 g). """ quantityGramsMin: Float """ Paints whose preferred supplier has this identifier (`Paint.supplierId`). """ supplierId: ID """ Only paints that changed at or after this moment (inclusive), as `Paint.updatedAt` shows it. For incremental sync: pass the latest `updatedAt` you have seen, minus a few minutes, and sort by `UPDATED_AT` ascending. Null or left out: no bound (the first run of a sync reads every one). """ updatedFrom: DateTime } """ What to sort paints by. Paints with equal values keep a fixed order (by identifier), so pages do not overlap. """ enum PaintSortField { """Warehouse code of the paint.""" CODE """When the paint was added.""" CREATED_AT """Manufacturer or brand (`group`).""" GROUP """When paint was last issued from stock.""" LAST_ISSUED_AT """Warehouse location.""" LOCATION """Name of the paint.""" NAME """Stock in grams.""" QUANTITY_GRAMS """ When the record last changed (`Paint.updatedAt`). Ascending, with `updatedFrom`, for incremental sync. """ UPDATED_AT } """How to sort paints.""" input PaintSortInput { """Ascending or descending.""" direction: SortDirection! """What to sort by.""" field: PaintSortField! } """One page of paints and the size of the whole list.""" type PaintsResult { """Paints on this page, in the requested sort order.""" items: [Paint!]! """Where this page is in the list and whether more pages follow.""" pageInfo: PageInfo! """ Number of items matching the filter on all pages together, not only on this one. """ totalCount: Int! } """ A paper (or other substrate) kept in the warehouse, with its stock in sheets. """ type Paper { """Barcode on the paper's labels; null when it has none.""" barcode: String """Warehouse code of the paper, unique and given by Prynt, e.g. "PA-12".""" code: String! """Color of the paper, as text (e.g. "white").""" color: String! """When the paper was added.""" createdAt: DateTime! """Currency of the purchase prices, a 3-letter code (e.g. PLN).""" currency: String! """Sheet format as text, e.g. "70x100", "SRA3" or "B1".""" format: String! """Sheet height in millimeters (up to 2 decimals); null when unknown.""" formatHeightMm: Float """Sheet width in millimeters (up to 2 decimals); null when unknown.""" formatWidthMm: Float """ FSC-certified part of the stock, in sheets: a whole number, never above `quantitySheets`. """ fscQuantitySheets: Float! """Grammage in g/m2, e.g. 130 or 300 (up to 2 decimals).""" grammage: Float! """Identifier of the paper.""" id: ID! """Whether the paper is also stocked as FSC-certified.""" isFsc: Boolean! """ True when the print shop keeps the paper in stock. False for a paper kept for pricing only (a calculation may still price it): the print shop does not track its stock, and an API key cannot receive or issue it (PAPER_PRICING_ONLY). Switching the flag changes nothing else: stock and movements booked earlier remain, and people in the app may still book it. Warehouse integrations usually filter `isStock: true`. """ isStock: Boolean! """When paper was last issued from stock; null when never.""" lastIssuedAt: DateTime """Warehouse location, e.g. "A-1-2"; null when not set.""" location: String """ Minimum stock level in sheets: below it the paper counts as low on stock (`lowStock` filter); null when not set. """ minimumStock: Float """Name of the paper, e.g. "Kreda mat 130g".""" name: String! """Notes of the warehouse about the paper; null when none.""" notes: String """The kind of paper.""" paperType: PaperType! """ Purchase price per kilogram, in `currency` (up to 4 decimals); null when not set. """ pricePerKg: Float """ Purchase price per sheet, in `currency` (up to 4 decimals); null when not set. """ pricePerSheet: Float """ Stock in kilograms as recorded on the card (up to 3 decimals; not recalculated from sheets); null when not kept. """ quantityKg: Float """ Stock in sheets: a whole number, never below zero. Every receipt, issue and stock-take adjustment changes it and is listed in `stockMovements`. """ quantitySheets: Float! """ The preferred supplier of the paper (`Query.supplier`); null when not set. """ supplierId: ID """ Supplier name as typed on the card (older papers); prefer `supplierId`. """ supplierName: String """ Unit the print shop buys and counts this paper in. The stock (`quantitySheets`) is always in sheets. """ unit: PaperUnit! """ When the paper or its stock last changed: an edit of the card that changes a field (saving the same values changes nothing), and every receipt, issue, purchase-order delivery and stock-take adjustment. What `updatedFrom` and the `UPDATED_AT` sort read. """ updatedAt: DateTime! } """ Conditions on papers: a paper is listed when it meets every condition given. Omitted conditions do not filter. """ input PaperFilterInput { """ The paper with exactly this barcode (case-insensitive), e.g. read by a scanner. """ barcode: String """Papers whose code contains this text (case-insensitive).""" code: String """ Papers whose format contains this text (case-insensitive), e.g. "70x100". """ format: String """Papers of this grammage or lighter (g/m2).""" grammageMax: Float """ Papers of this grammage or heavier (g/m2). The same value in `grammageMin` and `grammageMax` lists one grammage, e.g. 130. """ grammageMin: Float """ True: papers also stocked as FSC-certified (`isFsc`); false: papers that are not. Omit for both. """ isFsc: Boolean """ True: only papers the print shop keeps in stock; false: only papers kept for pricing only (`Paper.isStock`). Omit for both. """ isStock: Boolean """Papers whose warehouse location contains this text (case-insensitive).""" location: String """ True: only papers whose stock is below their minimum stock level (`minimumStock`); false: only papers at or above it or without a minimum. Omit for both. """ lowStock: Boolean """Papers whose name contains this text (case-insensitive).""" nameContains: String """Papers of this kind.""" paperType: PaperType """Papers with at most this many sheets in stock.""" quantitySheetsMax: Int """ Papers with at least this many sheets in stock; `quantitySheetsMin: 1` lists the papers really in stock. """ quantitySheetsMin: Int """ Papers whose preferred supplier has this identifier (`Paper.supplierId`). Older papers with a supplier typed as text only (`supplierName`) have none. """ supplierId: ID """ Only papers that changed at or after this moment (inclusive), as `Paper.updatedAt` shows it. For incremental sync: pass the latest `updatedAt` you have seen, minus a few minutes, and sort by `UPDATED_AT` ascending. Null or left out: no bound (the first run of a sync reads every one). """ updatedFrom: DateTime } """ What to sort papers by. Papers with equal values keep a fixed order (by identifier), so pages do not overlap. """ enum PaperSortField { """Warehouse code of the paper.""" CODE """When the paper was added.""" CREATED_AT """Sheet format, as text.""" FORMAT """Grammage in g/m2.""" GRAMMAGE """When paper was last issued from stock.""" LAST_ISSUED_AT """Warehouse location.""" LOCATION """Name of the paper.""" NAME """Paper type (`paperType`).""" PAPER_TYPE """Stock in sheets.""" QUANTITY_SHEETS """ When the record last changed (`Paper.updatedAt`). Ascending, with `updatedFrom`, for incremental sync. """ UPDATED_AT } """How to sort papers.""" input PaperSortInput { """Ascending or descending.""" direction: SortDirection! """What to sort by.""" field: PaperSortField! } """The kind of a paper (substrate) in the warehouse.""" enum PaperType { """Cardboard and board.""" CARDBOARD """Coated paper with a gloss finish.""" COATED_GLOSS """Coated paper with a matte finish.""" COATED_MATTE """Corrugated board.""" CORRUGATED """Self-adhesive material.""" SELF_ADHESIVE """Any other specialty substrate.""" SPECIALTY """Uncoated (offset) paper.""" UNCOATED } """ The unit the print shop buys and counts a paper in. The stock of every paper is kept in sheets all the same. """ enum PaperUnit { """Kilograms.""" KG """Rolls.""" ROLL """Sheets.""" SHEET } """One page of papers and the size of the whole list.""" type PapersResult { """Papers on this page, in the requested sort order.""" items: [Paper!]! """Where this page is in the list and whether more pages follow.""" pageInfo: PageInfo! """ Number of items matching the filter on all pages together, not only on this one. """ totalCount: Int! } """How a client pays for an order.""" enum PaymentMethod { """Cash on delivery.""" CASH_ON_DELIVERY """Cash on pickup at the print shop.""" CASH_ON_PICKUP """Online payment before shipping.""" ONLINE_PREPAID """Bank transfer after delivery.""" TRANSFER_POSTPAID """Bank transfer before shipping (prepayment).""" TRANSFER_PREPAID } """ Where payment of an order stands. Set by the print shop (or an integration through `updateOrder`); recording a payment does not change it. """ enum PaymentStatus { """Waiting for the payment.""" AWAITING_PAYMENT """Payment cancelled.""" CANCELLED """Invoiced.""" INVOICED """A payment link was sent to the client.""" LINK_SENT """Not paid by the due date.""" OVERDUE """Paid in full.""" PAID """Partly paid.""" PARTIALLY_PAID """Nothing to pay yet or not settled (the default).""" PENDING } """How a sheet is printed.""" enum PrintScheme { """ Both sides with a separate plate set for each side (F/F in the print shop). """ SHEETWISE """One side only, for example 4+0.""" SIMPLEX """ Both sides with one plate set, the sheet turned between the passes (F/O in the print shop). """ WORK_AND_TURN } """ A product of an order: one item the print shop makes (for example a book or leaflets), with its print run, price and production status. """ type Product { """ Additional costs charged on this product, by position. An empty list (never null) when there are none. """ additionalCosts: [AdditionalCost!] """ True when delivery must be announced to the recipient in advance (advice note). """ awizo: Boolean! """ Identifier of the product category (an entry of `referenceData(type: PRODUCT_CATEGORY)`); null when not set. """ categoryId: ID """Day the product is due (UTC midnight of that day); null when not set.""" dateDue: DateTime """ Description of the work for production (the job description); null when empty. """ description: String """ Elements of the product (for example cover and inside pages), in production order. An empty list (never null) when the product has no technology yet. """ elements: [Element!] """ Where to get the files of the product (for example a URL) when they are not uploaded to Prynt; null when not given. """ fileLink: String """ How the client delivers the files of the product, for example a link or FTP; null when not stated. """ fileType: String """ Files of the product (for example print files from the client), uploaded completely, newest first. An empty list (never null) when there are none. """ files: [File!] """ When prepress accepted the files of the product; null while they are not accepted. """ filesAcceptedAt: DateTime """Identifier of the product (UUID).""" id: ID! """True when the product is made of FSC-certified paper.""" isFsc: Boolean! """ True when the print shop hid the product (the "hide product" flag); it is still part of the order. """ isHidden: Boolean! """ISBN or ISSN of a publication; null when not applicable.""" isbnIssn: String """Name of the product, for example `Ulotka A5`.""" name: String! """ True when the product is not to be invoiced. Information for the office only: it changes no amounts or statuses. """ noInvoice: Boolean! """Position of the product within its order, from 1; unique in the order.""" number: Int! """ The order the product belongs to. Always set for an API key; null in the app for a person who may not see the order. """ order: Order """Identifier of the order the product belongs to.""" orderId: ID! """When the product is planned to be packed; null when not planned.""" packingDate: DateTime """ Net price of the whole product line (all `quantity` units together, not per unit), in the order currency. The net value of the product is `price + priceMarkup`. """ price: Float! """ Net markup added to `price`, as an amount in the order currency (not a percentage). """ priceMarkup: Float! """ How far production of the product has got: the roll-up of the operations of all its elements. """ production: ProductionProgress! """Print run: how many units of the product to make, in `unit`.""" quantity: Float! """ Stage of the product: its files, then production. Prynt moves it as files are checked and production tasks run; see `ProductStatus`. """ status: ProductStatus! """ VAT rate of the product as a fraction, for example `0.23` for 23%. (Inputs take it in percent: `23`.) """ taxRate: Float! """Unit of `quantity`.""" unit: Unit! """Weight of the whole product line in kilograms (0 when unknown).""" weight: Float! } """ A sales invoice the print shop issued for a product of an order, as recorded in Prynt (the invoice itself is issued in the accounting system). """ type ProductInvoice { """ Identifier of the billing entity of the print shop that issued the invoice (an entry of `billingEntities`); null when not recorded. """ billingEntityId: ID """When the invoice was recorded in Prynt.""" createdAt: DateTime! """ Code of the invoice currency, for example `PLN` or `EUR`: the currency of the order when the invoice was recorded. """ currencyCode: String! """ Identifier of the invoice currency (an entry of `currencies`): the currency of the order. Null on older invoices; `currencyCode` is always set. """ currencyId: ID """Payment due date (UTC midnight of that day); null when not set.""" dueDate: DateTime """ Exchange rate from the invoice currency to the print shop home currency used for the `*Home` amounts (1 for the home currency); by default the rate of the business day before the issue date. """ exchangeRate: Float """ The invoice document (for example its PDF): the newest file attached to the invoice; null when none was attached. """ file: File """Gross amount of the invoice, in the invoice currency (`currencyCode`).""" grossAmount: Float """Gross amount in the print shop home currency.""" grossHome: Float """Identifier of the invoice (UUID).""" id: ID! """Number of the invoice, as issued.""" invoiceNumber: String! """Date of issue (UTC midnight of that day).""" issueDate: DateTime! """Net amount of the invoice, in the invoice currency.""" netAmount: Float """Net amount in the print shop home currency.""" netHome: Float """ Identifier of the order of that product (`Order.id`): where the buyer is (`Order.clientId`, the invoice data of the order). It never changes for an invoice. """ orderId: ID! """Identifier of the product the invoice is for (`Product.id`).""" productId: ID! """ Day of the exchange rate (UTC midnight of that day); null when not recorded. """ rateDate: DateTime """ Number of the exchange rate table the rate comes from (for the National Bank of Poland, for example `192/A/NBP/2026`); null for the home currency or a rate entered by hand. """ rateTableNo: String """Type of the invoice.""" type: ProductInvoiceType! """ When the invoice or its file last changed. Filter on it with `updatedFrom` to fetch only what changed since your last sync. """ updatedAt: DateTime! """VAT amount of the invoice, in the invoice currency.""" vatAmount: Float """VAT amount in the print shop home currency.""" vatHome: Float """VAT rate of the invoice as a fraction, for example `0.23` for 23%.""" vatRate: Float } """ Conditions on product invoices: an invoice is listed when it meets every condition given. Omitted conditions do not filter. """ input ProductInvoiceFilterInput { """ Invoices issued by this billing entity of the print shop (an entry of `billingEntities`). """ billingEntityId: ID """Invoices whose number contains this text (case-insensitive).""" invoiceNumber: String """Invoices issued on or after this day (`ProductInvoice.issueDate`).""" issuedFrom: DateTime """Invoices issued on or before this day (`ProductInvoice.issueDate`).""" issuedTo: DateTime """Invoices of the products of this order (`Order.id`).""" orderId: ID """Invoices of this product (`Product.id`).""" productId: ID """Invoices of any of these types.""" type: [ProductInvoiceType!] """ Only invoices that changed at or after this moment (inclusive), as `ProductInvoice.updatedAt` shows it. For incremental sync: pass the latest `updatedAt` you have seen, minus a few minutes, and sort by `UPDATED_AT` ascending. Null or left out: no bound (the first run of a sync reads every one). """ updatedFrom: DateTime } """ What to sort product invoices by. Invoices with equal values keep a fixed order (by identifier), so pages do not overlap. """ enum ProductInvoiceSortField { """When the invoice was recorded in Prynt.""" CREATED_AT """Invoice number, as text (`10/2026` sorts before `9/2026`).""" INVOICE_NUMBER """Date of issue (`ProductInvoice.issueDate`).""" ISSUE_DATE """ When the record last changed (`ProductInvoice.updatedAt`). Ascending, with `updatedFrom`, for incremental sync. """ UPDATED_AT } """How to sort product invoices.""" input ProductInvoiceSortInput { """Ascending or descending.""" direction: SortDirection! """What to sort by.""" field: ProductInvoiceSortField! } """Type of an invoice of a product.""" enum ProductInvoiceType { """ Correcting invoice. Its amounts are positive like every other invoice and reduce what was invoiced for the product. """ CORRECTION """Pro forma invoice: a request for payment, not an accounting document.""" PROFORMA """VAT invoice.""" VAT } """One page of product invoices and the size of the whole list.""" type ProductInvoicesResult { """Invoices on this page, in the requested sort order.""" items: [ProductInvoice!]! """Where this page is in the list and whether more pages follow.""" pageInfo: PageInfo! """ Number of items matching the filter on all pages together, not only on this one. """ totalCount: Int! } """ Stage of a product: its print files, then production. Prynt moves it as files are uploaded and checked and as production tasks run. """ enum ProductStatus { """Cancelled.""" CANCELLED """Prepress accepted the files: the product may go into production.""" FILES_ACCEPTED """ Files uploaded and waiting for prepress to check them. Uploading a product file sets it. """ FILES_TO_CHECK """In production: the first production task started.""" IN_PRODUCTION """ No files yet: the product waits for print files. The usual status of a new product. """ NO_FILES """Ready: all operations of the product are done.""" READY """Released to the client.""" RECEIVED """ Waiting for prepress: the salesperson answered prepress's remarks without a new file. """ WAITING_FOR_ADMIN_RESPONSE """Waiting for the client: prepress asked for changes to the files.""" WAITING_FOR_CLIENT_RESPONSE } """ How far production of an element, a product or an order has got: the roll-up of all its operations. Computed when read from the operations and their tasks, so it moves with `Order.updatedAt`. """ type ProductionProgress { """ How many of the operations are completed (`Operation.productionStatus` COMPLETED). """ completedOperationCount: Int! """How many operations there are (0 when there are none yet).""" operationCount: Int! """ Share of the work done, 0 to 100 (one decimal place); 100 only when `status` is COMPLETED. Each operation counts by its quantity done, weighted by its planned machine time; an operation without a time estimate weighs as much as the average estimated one, and when none has an estimate, every operation weighs the same. """ percent: Float! """ Planned machine time of the operations, in seconds: the sum of `timePerUnitSeconds * quantity` (operations without a time estimate add nothing). An estimate of the print shop, not time measured on the shop floor. """ plannedSeconds: Int! """ Planned machine time of the work still to do, in seconds (0 once production is completed): `plannedSeconds` less the part already done. Operations without a time estimate add nothing, so it may be 0 before production is completed. """ remainingSeconds: Int! """ Where production stands across the operations: COMPLETED when every one is; IN_PROGRESS while a task runs, or while some operations are completed and the others wait their turn; PAUSED when an operation is interrupted part-way (a paused task, a part of its quantity) and none runs; NOT_STARTED while none has started (or there are none). """ status: ProductionStatus! } """ Where production stands: of one operation (`Operation.productionStatus`), or of all operations of an element, a product or an order (`ProductionProgress.status`). """ enum ProductionStatus { """ Production finished: the whole quantity is done (for an element, product or order: every operation). """ COMPLETED """ In production. For an operation: someone is working on it right now (a task is running). For an element, product or order: a task of one of its operations is running, or some operations are completed and the others wait their turn, none of them interrupted. """ IN_PROGRESS """ Nothing produced yet and nobody is working on it (a task may already be planned). Also an element, product or order without operations. """ NOT_STARTED """ Interrupted part-way and nobody is working on it right now: a task was paused, or part of the quantity is done and the rest waits. For an element, product or order: one of its operations is interrupted that way and none is running. """ PAUSED } """ A purchase invoice: an invoice a supplier issued to the print shop, recorded in the warehouse. """ type PurchaseInvoice { """Gross amount of the invoice, in `currency`; null when not recorded.""" amountGross: Float """Net amount of the invoice, in `currency`; null when not recorded.""" amountNet: Float """When the invoice was recorded in Prynt.""" createdAt: DateTime! """Code of the invoice currency, for example `PLN` or `EUR`.""" currency: String! """ The invoice document (for example its PDF): the newest file attached to the invoice; null when none was attached. """ file: File """Identifier of the invoice (UUID).""" id: ID! """Date of the invoice (UTC midnight of that day).""" invoiceDate: DateTime! """Number of the invoice, as the supplier issued it.""" invoiceNumber: String! """The supplier who issued the invoice; null when not recorded.""" supplier: Supplier """ Identifier of the supplier who issued the invoice (`Supplier.id`); null when not recorded. """ supplierId: ID """ When the invoice or its file last changed. Filter on it with `updatedFrom` to fetch only what changed since your last sync. """ updatedAt: DateTime! } """ Conditions on purchase invoices: an invoice is listed when it meets every condition given. Omitted conditions do not filter. """ input PurchaseInvoiceFilterInput { """Invoices whose number contains this text (case-insensitive).""" invoiceNumber: String """Invoices issued on or after this day (`PurchaseInvoice.invoiceDate`).""" issuedFrom: DateTime """Invoices issued on or before this day (`PurchaseInvoice.invoiceDate`).""" issuedTo: DateTime """Invoices of this supplier (`Supplier.id`).""" supplierId: ID """ Only purchase invoices that changed at or after this moment (inclusive), as `PurchaseInvoice.updatedAt` shows it. For incremental sync: pass the latest `updatedAt` you have seen, minus a few minutes, and sort by `UPDATED_AT` ascending. Null or left out: no bound (the first run of a sync reads every one). """ updatedFrom: DateTime } """ What to sort purchase invoices by. Invoices with equal values keep a fixed order (by identifier), so pages do not overlap. """ enum PurchaseInvoiceSortField { """When the invoice was recorded in Prynt.""" CREATED_AT """Date of the invoice (`PurchaseInvoice.invoiceDate`).""" INVOICE_DATE """Invoice number, as text (`10/2026` sorts before `9/2026`).""" INVOICE_NUMBER """ When the record last changed (`PurchaseInvoice.updatedAt`). Ascending, with `updatedFrom`, for incremental sync. """ UPDATED_AT } """How to sort purchase invoices.""" input PurchaseInvoiceSortInput { """Ascending or descending.""" direction: SortDirection! """What to sort by.""" field: PurchaseInvoiceSortField! } """One page of purchase invoices and the size of the whole list.""" type PurchaseInvoicesResult { """Invoices on this page, in the requested sort order.""" items: [PurchaseInvoice!]! """Where this page is in the list and whether more pages follow.""" pageInfo: PageInfo! """ Number of items matching the filter on all pages together, not only on this one. """ totalCount: Int! } """An order of materials from a supplier.""" type PurchaseOrder { """Code of the purchase order, unique and given by Prynt, e.g. "PO-240".""" code: String! """When the order was added.""" createdAt: DateTime! """Currency of the prices, a 3-letter code (e.g. PLN).""" currency: String! """When the delivery is expected; null when unknown.""" expectedDeliveryAt: DateTime """ Your integration's own identifier of the purchase order (`CreatePurchaseOrderInput.externalRef`); null until you set one. Each integration sees only its own; in the app it is always null. """ externalRef: String """Identifier of the purchase order.""" id: ID! """What is ordered: the items of the order.""" items: [PurchaseOrderItem!]! """Notes about the order; null when none.""" notes: String """When the order was placed; null when not recorded.""" orderedAt: DateTime """ When the last item arrived in full (the order became RECEIVED); null before. """ receivedAt: DateTime """Current status.""" status: PurchaseOrderStatus! """The supplier the goods are ordered from.""" supplier: Supplier """The supplier the goods are ordered from.""" supplierId: ID! """ Net total: the sum of quantity x unit price of the items, in `currency` (2 decimals); null when not computed. """ totalNet: Float """ When the order or its items last changed: an edit, a change of status or a delivery received. A change of the supplier itself does not move it. What `updatedFrom` and the `UPDATED_AT` sort read. """ updatedAt: DateTime! } """ Conditions on purchase orders: an order is listed when it meets every condition given. Omitted conditions do not filter. """ input PurchaseOrderFilterInput { """Orders whose code contains this text (case-insensitive).""" codeContains: String """ The purchase order your integration gave this `externalRef` (exact match): at most one order. A person in the app has no references, so for them it matches none. """ externalRef: String """Orders in this status.""" status: PurchaseOrderStatus """Orders from this supplier.""" supplierId: ID """ Only purchase orders that changed at or after this moment (inclusive), as `PurchaseOrder.updatedAt` shows it. For incremental sync: pass the latest `updatedAt` you have seen, minus a few minutes, and sort by `UPDATED_AT` ascending. Null or left out: no bound (the first run of a sync reads every one). """ updatedFrom: DateTime } """An item of a purchase order.""" type PurchaseOrderItem { """What is ordered, as the supplier names it.""" description: String! """Identifier of the item.""" id: ID! """ The paper, paint or foil whose stock a delivery of this item raises; null for goods kept outside the warehouse stock. """ materialId: ID """Kind of material ordered.""" materialType: MaterialType! """A note about the item; null when none.""" notes: String """The purchase order of the item.""" purchaseOrderId: ID! """Quantity ordered, in `unit` (up to 3 decimals).""" quantity: Float! """ Quantity received so far, in `unit` (up to 3 decimals); never above `quantity`. """ receivedQuantity: Float! """ Unit of the quantities, as text (e.g. ark., kg, rolki, mb). A delivery is converted to the stock unit of the material. """ unit: String! """ Net price of one `unit`, in the currency of the purchase order (up to 4 decimals). """ unitPrice: Float! } """ What to sort purchase orders by. Orders with equal values keep a fixed order (by identifier), so pages do not overlap. """ enum PurchaseOrderSortField { """Code of the purchase order.""" CODE """When the order was added.""" CREATED_AT """When the delivery is expected.""" EXPECTED_DELIVERY_AT """When the order was placed.""" ORDERED_AT """ When the record last changed (`PurchaseOrder.updatedAt`). Ascending, with `updatedFrom`, for incremental sync. """ UPDATED_AT } """How to sort purchase orders.""" input PurchaseOrderSortInput { """Ascending or descending. Default DESC.""" direction: SortDirection! = DESC """What to sort by.""" field: PurchaseOrderSortField! } """Where a purchase order is: from a draft to the last delivery.""" enum PurchaseOrderStatus { """Cancelled. Takes no change.""" CANCELLED """Confirmed by the supplier.""" CONFIRMED """Being prepared; not sent to the supplier yet.""" DRAFT """Part of the goods arrived; more is expected.""" PARTIALLY_RECEIVED """Every item arrived in full. Takes no change.""" RECEIVED """Sent to the supplier; deliveries can be received.""" SENT } """One page of purchase orders and the size of the whole list.""" type PurchaseOrdersResult { """Purchase orders on this page, in the requested sort order.""" items: [PurchaseOrder!]! """Where this page is in the list and whether more pages follow.""" pageInfo: PageInfo! """ Number of items matching the filter on all pages together, not only on this one. """ totalCount: Int! } type Query { """ The print shop's own companies that invoice its orders (billing entities), one page at a time, with the total count: what `Order.billingEntityId`, `Client.defaultInvoiceBillingEntityId` and `ProductInvoice.billingEntityId` point at. A small list that rarely changes: read it whole and keep it. """ billingEntities( """ Conditions the billing entities must meet; without it every billing entity is listed. """ filter: BillingEntityFilterInput """ Page of the list to return; without it the first page at the default size. """ pagination: PaginationInput """Order of the list; without it alphabetical by name.""" sort: BillingEntitySortInput ): BillingEntitiesResult! """ One billing entity by its identifier; null when there is no such entity. """ billingEntity( """Identifier of the billing entity.""" id: ID! ): BillingEntity """One client by its identifier; null when there is no such client.""" client( """Identifier of the client.""" id: ID! ): Client """ Every tag the print shop marks clients with, by name. The print shop manages the list in Prynt; give a client a tag with `assignClientTag`. """ clientTags: [ClientTag!]! """ Clients, one page at a time, with the total count. Filter and sort them; with `updatedFrom` and the `UPDATED_AT` sort, fetch only clients changed since your last sync; with `externalRef`, find the client you gave that reference. """ clients( """Conditions the clients must meet; without it every client is listed.""" filter: ClientFilterInput """ Page of the list to return; without it the first page at the default size. """ pagination: PaginationInput """Order of the list; without it alphabetical by display name.""" sort: ClientSortInput ): ClientsResult! """ Currencies the print shop sells in, in its display order: what `Order.currencyId`, `Client.defaultCurrencyId` and `ProductInvoice.currencyId` point at. A small list that rarely changes: read it whole with `includeInactive: true` and keep it — older orders still point at currencies the print shop no longer offers. """ currencies( """ True: also the currencies the print shop no longer offers (`isActive` false). Default false: only the currencies offered now — use true for a copy that resolves the ids of older records. """ includeInactive: Boolean! = false ): [Currency!]! """ The API key this request was made with: its integration, the scopes it may use, when the key and the approval of the integration expire, and the rate limit. Needs no scope, so any valid key may call it: use it to check that a key works. """ currentApiKey: CurrentApiKey! """ One die-cut by its identifier, archived or not; null when there is no such die-cut. """ dieCut( """Identifier of the die-cut.""" id: ID! ): DieCut """ Die-cuts in the warehouse, one page at a time, with the total count; archived ones only on request (`isArchived`) or when syncing. Filter and sort them; with `updatedFrom` and the `UPDATED_AT` sort, fetch only die-cuts changed since your last sync. """ dieCuts( """Conditions the die-cuts must meet; without it every die-cut is listed.""" filter: DieCutFilterInput """ Page of the list to return; without it the first page at the default size. """ pagination: PaginationInput """Order of the list; without it newest first.""" sort: DieCutSortInput ): DieCutsResult! """One foil by its identifier; null when there is no such foil.""" foil( """Identifier of the foil.""" id: ID! ): Foil """ Foils in the warehouse with their stock, one page at a time, with the total count. Filter and sort them; with `updatedFrom` and the `UPDATED_AT` sort, fetch only foils whose card or stock changed since your last sync. """ foils( """Conditions the foils must meet; without it every foil is listed.""" filter: FoilFilterInput """ Page of the list to return; without it the first page at the default size. """ pagination: PaginationInput """Order of the list; without it newest first.""" sort: FoilSortInput ): FoilsResult! """One machine by its identifier; null when there is no such machine.""" machine( """Identifier of the machine.""" id: ID! ): Machine """ Machines of the print shop, one page at a time, with the total count: what `Operation.machineId` and `Task.machineId` point at, decommissioned ones included (`isActive` false; older operations still point at them). A small list that rarely changes: read it whole, without the `isActive` filter, and keep it. """ machines( """Conditions the machines must meet; without it every machine is listed.""" filter: MachineFilterInput """ Page of the list to return; without it the first page at the default size. """ pagination: PaginationInput """Order of the list; without it alphabetical by name.""" sort: MachineSortInput ): MachinesResult! """ Matrices in the warehouse, one page at a time, with the total count; archived ones only on request (`isArchived`) or when syncing. Filter and sort them; with `updatedFrom` and the `UPDATED_AT` sort, fetch only matrices changed since your last sync. """ matrices( """Conditions the matrices must meet; without it every matrix is listed.""" filter: MatrixFilterInput """ Page of the list to return; without it the first page at the default size. """ pagination: PaginationInput """Order of the list; without it newest first.""" sort: MatrixSortInput ): MatricesResult! """ One matrix by its identifier, archived or not; null when there is no such matrix. """ matrix( """Identifier of the matrix.""" id: ID! ): Matrix """One operation of an order by its identifier; null when there is none.""" operation( """Identifier of the operation.""" id: ID! ): Operation """ Operations of the orders' elements, one page at a time, with the total count: the shop floor's work by machine, by where production stands (with the production scope) and by what changed since your last sync (`updatedFrom`). Without `sort`: by the completion date of the order, nearest first, then by identifier. """ operations( """ Conditions the operations must meet; without it every operation is listed. """ filter: OperationFilterInput """ Page of the list to return; without it the first page at the default size. """ pagination: PaginationInput """ Order of the list; without it by the completion date of the order, nearest first, then by identifier. """ sort: OperationSortInput ): OperationsResult! """One order by its identifier; null when there is no such order.""" order( """Identifier of the order.""" id: ID! ): Order """ Orders, one page at a time, with the total count. Filter and sort them; with `updatedFrom` and the `UPDATED_AT` sort, fetch only orders changed since your last sync. """ orders( """Conditions the orders must meet; without it every order is listed.""" filter: OrderFilterInput """ Page of the list to return; without it the first page at the default size. """ pagination: PaginationInput """Order of the list; without it newest first.""" sort: OrderSortInput ): OrdersResult! """One paint by its identifier; null when there is no such paint.""" paint( """Identifier of the paint.""" id: ID! ): Paint """ Paints in the warehouse with their stock, one page at a time, with the total count. Filter and sort them; with `updatedFrom` and the `UPDATED_AT` sort, fetch only paints whose card or stock changed since your last sync. """ paints( """Conditions the paints must meet; without it every paint is listed.""" filter: PaintFilterInput """ Page of the list to return; without it the first page at the default size. """ pagination: PaginationInput """Order of the list; without it newest first.""" sort: PaintSortInput ): PaintsResult! """One paper by its identifier; null when there is no such paper.""" paper( """Identifier of the paper.""" id: ID! ): Paper """ Papers in the warehouse with their stock, one page at a time, with the total count. Filter and sort them; with `updatedFrom` and the `UPDATED_AT` sort, fetch only papers whose card or stock changed since your last sync. """ papers( """Conditions the papers must meet; without it every paper is listed.""" filter: PaperFilterInput """ Page of the list to return; without it the first page at the default size. """ pagination: PaginationInput """Order of the list; without it newest first.""" sort: PaperSortInput ): PapersResult! """ One product of an order by its identifier; null when there is no such product. """ product( """Identifier of the product.""" id: ID! ): Product """ One sales invoice of a product by its identifier; null when there is no such invoice. """ productInvoice( """Identifier of the invoice.""" id: ID! ): ProductInvoice """ Sales invoices of the products of orders, one page at a time, with the total count. Filter by order, product, billing entity, type or issue date; with `updatedFrom` and the `UPDATED_AT` sort, fetch only invoices recorded or changed since your last sync. Without a sort: the latest issued first. """ productInvoices( """Conditions the invoices must meet; without it every invoice is listed.""" filter: ProductInvoiceFilterInput """ Page of the list to return; without it the first page at the default size. """ pagination: PaginationInput """Order of the list; without it the latest issued first.""" sort: ProductInvoiceSortInput ): ProductInvoicesResult! """ One purchase invoice by its identifier; null when there is no such invoice. """ purchaseInvoice( """Identifier of the invoice.""" id: ID! ): PurchaseInvoice """ Purchase invoices (from suppliers), one page at a time, with the total count. Filter by supplier, number or date; with `updatedFrom` and the `UPDATED_AT` sort, fetch only invoices recorded or changed since your last sync. Without a sort: the latest invoice date first. """ purchaseInvoices( """Conditions the invoices must meet; without it every invoice is listed.""" filter: PurchaseInvoiceFilterInput """ Page of the list to return; without it the first page at the default size. """ pagination: PaginationInput """Order of the list; without it the latest invoice date first.""" sort: PurchaseInvoiceSortInput ): PurchaseInvoicesResult! """ One purchase order by its identifier; null when there is no such order. """ purchaseOrder( """Identifier of the purchase order.""" id: ID! ): PurchaseOrder """ Purchase orders to suppliers, one page at a time, with the total count. Filter and sort them; with `updatedFrom` and the `UPDATED_AT` sort, fetch only orders changed since your last sync; with `externalRef`, find the order you gave that reference. """ purchaseOrders( """ Conditions the purchase orders must meet; without it every purchase order is listed. """ filter: PurchaseOrderFilterInput """ Page of the list to return; without it the first page at the default size. """ pagination: PaginationInput """Order of the list; without it latest ordered first.""" sort: PurchaseOrderSortInput ): PurchaseOrdersResult! """ Entries of one dictionary of the print shop (operation types, color profiles, product categories…), in its display order: what the `…TypeId`, `colorProfileId` and `categoryId` fields of orders point at. Small lists that rarely change: read them whole with `includeInactive: true` and keep them — older orders still point at entries the print shop no longer offers. """ referenceData( """ True: also the entries the print shop no longer offers (`isActive` false). Default false: only the entries offered now — use true for a copy that resolves the ids of older records. """ includeInactive: Boolean! = false """Which dictionary to read.""" type: ReferenceDataType! ): [ReferenceDataItem!]! """ Movements of paper, paint and foil stock — receipts (also purchase-order deliveries), issues, corrections and stock-take adjustments — one page at a time, with the total count; newest first unless sorted. Each movement says the stock before and after it, read under a lock of the material, so the movements of one material chain together: each one starts from the stock the one before it left. The stock entered when a card is created is a `CORRECTION` from 0 since version 0.34.0; the opening stock of older cards and changes made before version 0.28.0 have no movement, so reconcile with the stock levels of the materials (`papers`, `paints`, `foils`). Movements are only ever added and their quantities and time never change: sync them with `occurredFrom` and the `OCCURRED_AT` sort. """ stockMovements( """ Conditions the movements must meet; without it every movement is listed. """ filter: StockMovementFilterInput """ Page of the list to return; without it the first page at the default size. """ pagination: PaginationInput """Order of the list; without it newest first.""" sort: StockMovementSortInput ): StockMovementsResult! """ One stock take by its identifier; null when there is no such stock take. """ stockTake( """Identifier of the stock take.""" id: ID! ): StockTake """ Stock takes, one page at a time, with the total count; newest first unless sorted. With `updatedFrom` and the `UPDATED_AT` sort, fetch only stock takes changed since your last sync. What an approved stock take changed in the stock is in `stockMovements` (`stockTakeId`). """ stockTakes( """ Conditions the stock takes must meet; without it every stock take is listed. """ filter: StockTakeFilterInput """ Page of the list to return; without it the first page at the default size. """ pagination: PaginationInput """Order of the list; without it newest first.""" sort: StockTakeSortInput ): StockTakesResult! """One supplier by its identifier; null when there is no such supplier.""" supplier( """Identifier of the supplier.""" id: ID! ): Supplier """ Suppliers of warehouse materials, one page at a time, with the total count. Filter and sort them; with `updatedFrom` and the `UPDATED_AT` sort, fetch only suppliers changed since your last sync. """ suppliers( """ Conditions the suppliers must meet; without it every supplier is listed. """ filter: SupplierFilterInput """ Page of the list to return; without it the first page at the default size. """ pagination: PaginationInput """Order of the list; without it alphabetical by name.""" sort: SupplierSortInput ): SuppliersResult! """ One production task by its identifier; null when there is no such task. """ task( """Identifier of the task.""" id: ID! ): Task """ Production tasks, one page at a time, with the total count: what the shop floor is doing on the operations of orders, with status and times. Filter by order, operation, machine or status; with `updatedFrom` and the `UPDATED_AT` sort, fetch only tasks changed since your last sync. Without a sort: earliest due date first (tasks without one last), then the most recently created first. """ tasks( """Conditions the tasks must meet; without it every task is listed.""" filter: TaskFilterInput """ Page of the list to return; without it the first page at the default size. """ pagination: PaginationInput """ Order of the list; without it earliest due date first (tasks without one last), then the most recently created first. """ sort: TaskSortInput ): TasksResult! """ VAT rates the print shop uses on products and invoices, in its display order. A small list that rarely changes: read it whole with `includeInactive: true` and keep it — older records still use rates the print shop no longer offers. """ vatRates( """ True: also the rates the print shop no longer offers (`isActive` false). Default false: only the rates offered now — use true for a copy that interprets older records. """ includeInactive: Boolean! = false ): [VatRate!]! } """ A receipt of foil into stock, e.g. a delivery booked outside purchase orders. """ input ReceiveFoilInput { """ Currency of `unitPrice`, a 3-letter code in capitals (e.g. PLN). Default: the currency of the card (`Foil.currency`). Only with `unitPrice`. """ currency: String """ When the goods were delivered, as the delivery document says; null or left out: not recorded (the movement still gets `StockMovement.occurredAt`, when it was booked). """ deliveredAt: DateTime """ Number of the delivery document (delivery note or supplier invoice), up to 100 characters; null, blank or left out: none. `StockMovementFilterInput.documentNumber` finds the movement by it. """ documentNumber: String """A note about the receipt, up to 2000 characters.""" notes: String """ Unit `unitPrice` is for, compared without case: rolki (also rolka, rolek, rol., roll, rolls) — one roll of stock — or m (also mb, mb.) — one meter, counted through `Foil.metersPerRoll`; written on the movement as rolki or m. Two rolls of 150 m at 1.85 per meter: `rollsToAdd` 2, `unitPrice` 1.85, `priceUnit` m — `StockMovement.netValue` 555.00. Default: rolki. Only with `unitPrice`. From an API key, a unit not listed here is refused (STOCK_UNIT_NOT_CONVERTIBLE). So are meters of a foil without meters per roll. """ priceUnit: String """Rolls received: above zero, kept to 0.01 roll.""" rollsToAdd: Float! """ The supplier the foil was received from (`Query.supplier`): must exist; from an API key it must be active (`Supplier.isActive`). Null or left out: not recorded (the supplier of the card is not filled in). """ supplierId: ID """ Net price of one `priceUnit`, in `currency` (up to 4 decimals, zero or more); null or left out: no price recorded. The price on the material's card does not change: the card is the print shop's, the receipt records what this delivery cost (`StockMovement.unitPrice`, `StockMovement.netValue`). """ unitPrice: Float } """ A receipt of paint into stock, e.g. a delivery booked outside purchase orders. """ input ReceivePaintInput { """ Currency of `unitPrice`, a 3-letter code in capitals (e.g. PLN). Default: the currency of the card (`Paint.currency`). Only with `unitPrice`. """ currency: String """ When the goods were delivered, as the delivery document says; null or left out: not recorded (the movement still gets `StockMovement.occurredAt`, when it was booked). """ deliveredAt: DateTime """ Number of the delivery document (delivery note or supplier invoice), up to 100 characters; null, blank or left out: none. `StockMovementFilterInput.documentNumber` finds the movement by it. """ documentNumber: String """A note about the receipt, up to 2000 characters.""" notes: String """ Unit `unitPrice` is for, compared without case: g (also gram, grams) — one gram of stock — or kg — 1000 g; written on the movement as g or kg. A paint received by the kilogram: `quantityToAdd` 5000 (grams), `unitPrice` 52.30, `priceUnit` kg — `StockMovement.netValue` 261.50. Default: g. Only with `unitPrice`. From an API key, a unit not listed here is refused (STOCK_UNIT_NOT_CONVERTIBLE). """ priceUnit: String """Grams received: above zero, kept to 0.001 g.""" quantityToAdd: Float! """ The supplier the paint was received from (`Query.supplier`): must exist; from an API key it must be active (`Supplier.isActive`). Null or left out: not recorded (the supplier of the card is not filled in). """ supplierId: ID """ Net price of one `priceUnit`, in `currency` (up to 4 decimals, zero or more); null or left out: no price recorded. The price on the material's card does not change: the card is the print shop's, the receipt records what this delivery cost (`StockMovement.unitPrice`, `StockMovement.netValue`). """ unitPrice: Float } """ A receipt of paper into stock, e.g. a delivery booked outside purchase orders. """ input ReceivePaperInput { """ Currency of `unitPrice`, a 3-letter code in capitals (e.g. PLN). Default: the currency of the card (`Paper.currency`). Only with `unitPrice`. """ currency: String """ When the goods were delivered, as the delivery document says; null or left out: not recorded (the movement still gets `StockMovement.occurredAt`, when it was booked). """ deliveredAt: DateTime """ Number of the delivery document (delivery note or supplier invoice), up to 100 characters; null, blank or left out: none. `StockMovementFilterInput.documentNumber` finds the movement by it. """ documentNumber: String """ True: the paper received is FSC-certified, so the FSC stock (`Paper.fscQuantitySheets`) grows by the same sheets; refused from an API key when the paper is not FSC-certified (`Paper.isFsc` false). Default false. """ isFsc: Boolean """A note about the receipt, up to 2000 characters.""" notes: String """ Unit `unitPrice` is for, compared without case: ark. (also ark, arkusz, arkusze, arkuszy, szt, szt., sheet, sheets) — one sheet of stock, written on the movement as ark. Default: ark. Only with `unitPrice`. From an API key, a unit not listed here is refused (STOCK_UNIT_NOT_CONVERTIBLE). """ priceUnit: String """Sheets received: a whole number above zero.""" quantityToAdd: Float! """ The supplier the paper was received from (`Query.supplier`): must exist; from an API key it must be active (`Supplier.isActive`). Null or left out: not recorded (the supplier of the card is not filled in). """ supplierId: ID """ Net price of one `priceUnit`, in `currency` (up to 4 decimals, zero or more); null or left out: no price recorded. The price on the material's card does not change: the card is the print shop's, the receipt records what this delivery cost (`StockMovement.unitPrice`, `StockMovement.netValue`). """ unitPrice: Float } """A delivery received against a purchase order.""" input ReceivePurchaseOrderInput { """ When the goods were delivered, as the delivery document says; copied to every stock movement of this delivery (`StockMovement.deliveredAt`). Null or left out: not recorded. """ deliveredAt: DateTime """ Number of the delivery document (delivery note or supplier invoice), up to 100 characters; copied to every stock movement of this delivery, so `stockMovements` filtered by `purchaseOrderId` and `documentNumber` tells a delivery already booked. Null, blank or left out: none. """ documentNumber: String """The items that arrived: at least one, each item once.""" items: [ReceivePurchaseOrderItemInput!]! """ A note about the delivery; null when none. The number of the delivery note goes to `documentNumber`. """ notes: String } """How much of one item arrived.""" input ReceivePurchaseOrderItemInput { """The item of the purchase order (`PurchaseOrderItem.id`).""" itemId: ID! """ Quantity that arrived in this delivery, in the unit of the item: above zero, and with what was received before at most the quantity ordered. """ receivedQuantity: Float! } """ An entry of a dictionary of the print shop, for example an operation type or a color profile. """ type ReferenceDataItem { """ Code of the entry, unique in its dictionary (UPPER_SNAKE_CASE), for example `OFFSET`. """ code: String! """Description of the entry; null when empty.""" description: String """ How many of this sheet are cut from one sheet of `parentId`; only for `SHEET_FORMAT` entries, null in other dictionaries. """ divisor: Int """ Height of the sheet in millimetres; only for `SHEET_FORMAT` entries, null in other dictionaries. """ heightMm: Int """Identifier of the entry (UUID).""" id: ID! """ False when the print shop no longer offers the entry (older records may still point at it). """ isActive: Boolean! """ What the sheet is used as: bought, printed or both; only for `SHEET_FORMAT` entries, null in other dictionaries. """ kind: SheetFormatKind """Name of the entry in the print shop.""" name: String! """ Identifier of the format the sheet is cut from (another `SHEET_FORMAT` entry); null for a sheet not cut from another one and in other dictionaries. """ parentId: ID """Position of the entry in its dictionary, from 0.""" sortOrder: Int! """The dictionary the entry belongs to.""" type: ReferenceDataType! """ Width of the sheet in millimetres; only for `SHEET_FORMAT` entries, null in other dictionaries. """ widthMm: Int } """Which dictionary of the print shop to read.""" enum ReferenceDataType { """ Color profiles of printing, for example 4+4 (`Operation.colorProfileId`). """ COLOR_PROFILE """ Types of product elements, for example a cover (`Element.elementTypeId`). """ ELEMENT_TYPE """ Types of finishing, for example laminating (`Operation.finishingTypeId`). """ FINISHING_TYPE """ Types of operations, for example printing (`Operation.operationTypeId`). """ OPERATION_TYPE """Categories of products (`Product.categoryId`).""" PRODUCT_CATEGORY """ Sheet formats of the calculator, for example B2 (`ElementSpec.printFormatId`, `ElementSpec.purchaseFormatId`); only these entries carry `widthMm`, `heightMm`, `kind`, `parentId` and `divisor`. """ SHEET_FORMAT } """What a sheet format is used as.""" enum SheetFormatKind { """ A sheet used both ways: bought from the supplier and printed in this size. """ BOTH """A sheet that goes through the press.""" PRINT """A sheet bought from the supplier and cut for printing.""" PURCHASE } """Direction of a sorted list.""" enum SortDirection { """Ascending: smallest, oldest or alphabetically first.""" ASC """Descending: largest, newest or alphabetically last first.""" DESC } """ A kind of material the warehouse keeps stock of. Tools (die-cuts, matrices) are counted by uses and have no stock movements. """ enum StockMaterialType { """Foil (`Query.foil`), stock in rolls.""" FOIL """Paint (`Query.paint`), stock in grams.""" PAINT """Paper (`Query.paper`), stock in sheets.""" PAPER } """ One change of a material stock: a receipt, an issue, a correction or a stock-take adjustment. Its quantities, time and the delivery details of a receipt (price, supplier, delivery document) never change once it is booked, so a sync reads movements by `occurredAt`. Its links to other records (`orderId`, `productId`, `elementId`, `operationId`, `purchaseOrderId`, `supplierId`) become null when that record is deleted in Prynt, and deleting a material deletes its movements: a periodic full read catches both. """ type StockMovement { """ Currency of `unitPrice` and `netValue`, a 3-letter code (e.g. PLN): given with the receipt (the currency of the card when none was given) or the currency of the purchase order. Null when `unitPrice` is null. """ currency: String """ When the goods were delivered, as the delivery document says — given with the receipt; null when not given. Not `occurredAt`: that is when the movement was booked, and what `occurredFrom` reads. """ deliveredAt: DateTime """ Why the stock take found a difference (adjustments only); null otherwise. """ discrepancyReason: StockTakeDiscrepancyReason """ Number of the delivery document (delivery note or supplier invoice) given with the receipt, e.g. "WZ 412/2026"; null when none. With `purchaseOrderId` it tells a delivery already booked from one still to book (`StockMovementFilterInput.documentNumber`). """ documentNumber: String """The element of the product; null when not recorded.""" elementId: ID """Identifier of the movement.""" id: ID! """ The material whose stock moved: a paper, a paint or a foil, by `materialType`. """ materialId: ID! """Kind of material whose stock moved.""" materialType: StockMaterialType! """ Net value of the goods received, in `currency` (2 decimals): the quantity received in `priceUnit` times `unitPrice`, computed when the receipt was booked — for a purchase-order delivery the quantity of the delivery in the unit of the item, whatever the stock precision rounds off. Null when `unitPrice` is null, or when a receipt booked by hand in the app gave a unit the material is not counted in. """ netValue: Float """Note entered with the movement; null when none.""" notes: String """ When the movement was booked. What `occurredFrom` and the `OCCURRED_AT` sort read. Movements of one material booked within the same moment may sort in another order than the chain of their quantities. """ occurredAt: DateTime! """The operation of the element; null when not recorded.""" operationId: ID """ The order the material was issued for; null when none, or when that order was deleted. """ orderId: ID """ Unit `unitPrice` is for, as the movement writes it: ark. (a sheet), g or kg (paint), rolki or m (foil) — the unit given with a receipt by hand (the stock unit when none was given) or the unit of the purchase-order item. Not necessarily `unit`: a paint priced by the kilogram is stocked in grams. A unit the material is not counted in, accepted in the app, stays as it was given. Null when `unitPrice` is null. """ priceUnit: String """The product of the order; null when not recorded.""" productId: ID """ The purchase order whose delivery this receipt booked; null otherwise, or when that purchase order was deleted. """ purchaseOrderId: ID """ Stock after the movement, in `unit`; null for older foil movements recorded without rolls. """ quantityAfter: Float """ Stock before the movement, in `unit`: the stock really there when it was booked, so it equals `quantityAfter` of the movement of the same material booked just before it. Null for older foil movements recorded without rolls. """ quantityBefore: Float """ How the stock changed, in `unit`: positive when it rose (a receipt), negative when it dropped (an issue); `quantityAfter` minus `quantityBefore`. Null when either is null. """ quantityChange: Float """The stock take whose approval booked this adjustment; null otherwise.""" stockTakeId: ID """ The supplier the goods were received from: given with a receipt booked by hand, or the supplier of the purchase order for a delivery. Null when not recorded, or when that supplier was deleted in Prynt. """ supplierId: ID """What moved the stock.""" type: StockMovementType! """Unit of the quantities: the stock unit of the material.""" unit: StockUnit! """ Net price of one `priceUnit` of the goods received, in `currency` (up to 4 decimals): the price given with a receipt booked by hand, or the unit price of the purchase-order item a delivery was received against, as it was when the delivery was booked (a later change of the item leaves it). Null for issues, corrections, stock-take adjustments and receipts booked without a price (also every receipt booked before version 0.33.0). """ unitPrice: Float } """ Conditions on stock movements: a movement is listed when it meets every condition given. Omitted conditions do not filter. """ input StockMovementFilterInput { """ Only movements booked with exactly this delivery document number (`StockMovement.documentNumber`), without case — not a part of it, like `PaperFilterInput.barcode` (`PurchaseInvoiceFilterInput.invoiceNumber` matches a part). With `purchaseOrderId` it tells whether a delivery note was already received. Up to 100 characters; blank: no condition. """ documentNumber: String """ Only movements booked for this element of a product (`StockMovement.elementId`). Since 0.32.0 an issue records the element of the operation it names; older issues only the ids they were given. """ elementId: ID """Only movements of this material (a paper, a paint or a foil).""" materialId: ID """Only movements of this kind of material.""" materialType: StockMaterialType """ Only movements booked at or after this moment (inclusive). For incremental sync: pass the latest `occurredAt` you have seen, minus a few minutes, sort by `OCCURRED_AT` ascending and skip the movements you already have (by `id`). Null or left out: no lower bound. """ occurredFrom: DateTime """ Only movements booked before this moment (exclusive), e.g. the end of a reporting period. Null or left out: no upper bound. """ occurredTo: DateTime """ Only movements booked for this operation of an element (`StockMovement.operationId`). """ operationId: ID """ Only movements booked for this order (`StockMovement.orderId`). Since 0.32.0 an issue records the order of the product, element or operation it names; older issues only the ids they were given. """ orderId: ID """ Only movements booked for this product of an order (`StockMovement.productId`). Since 0.32.0 an issue records the product of the element or operation it names; older issues only the ids they were given. """ productId: ID """Only receipts of deliveries of this purchase order.""" purchaseOrderId: ID """ Only receipts of goods from this supplier (`StockMovement.supplierId`): receipts booked by hand with this supplier and deliveries of its purchase orders. """ supplierId: ID """ Only movements of this type, as `StockMovement.type` shows it: RECEIPT is a receipt or a purchase-order delivery that raised the stock, RETURN a return to the supplier (older foil movements recorded without rolls count as RETURN too). A correction or a stock-take difference keeps its own type, even when it raised the stock. Ignored when `typeIn` lists any type. """ type: StockMovementType """ Only movements of any of these types (see `type`). An empty list filters nothing. """ typeIn: [StockMovementType!] } """ What to sort stock movements by. Movements booked in the same instant keep a fixed order (by identifier), so pages do not overlap. """ enum StockMovementSortField { """ When the movement was booked (`occurredAt`). Ascending, with `occurredFrom`, for incremental sync. """ OCCURRED_AT } """How to sort stock movements.""" input StockMovementSortInput { """Ascending or descending.""" direction: SortDirection! """What to sort by.""" field: StockMovementSortField! } """What moved the stock.""" enum StockMovementType { """ A correction of the recorded stock: an issue booked as a correction (the stock drops), a stock set by hand on the material card in Prynt (the stock rises or drops), or the stock entered when the card was created, booked from 0. """ CORRECTION """ The difference a stock take found, booked when it was approved (`stockTakeId`). The stock rises or drops. """ INVENTORY_ADJUSTMENT """Issued for any other reason. The stock drops.""" OTHER """Issued to production. The stock drops.""" PRODUCTION """ Goods received: a receipt booked by hand or a purchase-order delivery (`purchaseOrderId`). The stock rises. """ RECEIPT """ Returned to the supplier. The stock drops. Some older foil movements were recorded without rolls (`quantityBefore` null): a receipt among them shows as RETURN too. """ RETURN """Wasted or damaged. The stock drops.""" WASTE } """One page of stock movements and the size of the whole list.""" type StockMovementsResult { """Movements on this page, in the requested sort order.""" items: [StockMovement!]! """Where this page is in the list and whether more pages follow.""" pageInfo: PageInfo! """ Number of items matching the filter on all pages together, not only on this one. """ totalCount: Int! } """ A stock take: counting what the warehouse holds. Approving it books each difference as a stock movement. """ type StockTake { """Code of the stock take, unique and given by Prynt, e.g. "INV-2026-03".""" code: String! """When the stock take was approved or cancelled; null before.""" completedAt: DateTime """When the stock take was added.""" createdAt: DateTime! """Identifier of the stock take.""" id: ID! """Name of the stock take.""" name: String! """Notes about the stock take; null when none.""" notes: String """What the stock take counts.""" scope: StockTakeScope! """When counting started; null before.""" startedAt: DateTime """Current status.""" status: StockTakeStatus! """ When the stock take last changed: its status, name or notes (counting single items does not move it). What `updatedFrom` and the `UPDATED_AT` sort read. """ updatedAt: DateTime! } """Why the stock counted in a stock take differs from the recorded stock.""" enum StockTakeDiscrepancyReason { """Damaged.""" DAMAGE """Found: more in stock than recorded.""" FOUND """Lost or stolen.""" LOSS """An earlier count was wrong.""" MISCOUNT """Any other reason.""" OTHER """A return that was not booked.""" RETURN_NOT_BOOKED """The supplier delivered a different amount.""" SUPPLIER_ERROR """Used without an issue being booked.""" UNRECORDED_USAGE } """ Conditions on stock takes: a stock take is listed when it meets every condition given. Omitted conditions do not filter. """ input StockTakeFilterInput { """Stock takes that count this.""" scope: StockTakeScope """Stock takes whose name or code contains this text (case-insensitive).""" search: String """Stock takes in this status.""" status: StockTakeStatus """ Only stock takes that changed at or after this moment (inclusive), as `StockTake.updatedAt` shows it. For incremental sync: pass the latest `updatedAt` you have seen, minus a few minutes, and sort by `UPDATED_AT` ascending. Null or left out: no bound (the first run of a sync reads every one). """ updatedFrom: DateTime } """What a stock take counts.""" enum StockTakeScope { """A selection made in the app.""" CUSTOM """Die-cuts only.""" DIE_CUTS """Foils only.""" FOILS """Everything in the warehouse.""" FULL """Matrices only.""" MATRICES """Paints only.""" PAINTS """Papers only.""" PAPERS } """ What to sort stock takes by. Stock takes with equal values keep a fixed order (by identifier), so pages do not overlap. """ enum StockTakeSortField { """Code of the stock take.""" CODE """When the stock take was added.""" CREATED_AT """Name of the stock take.""" NAME """Status of the stock take.""" STATUS """ When the record last changed (`StockTake.updatedAt`). Ascending, with `updatedFrom`, for incremental sync. """ UPDATED_AT } """How to sort stock takes.""" input StockTakeSortInput { """Ascending or descending.""" direction: SortDirection! """What to sort by.""" field: StockTakeSortField! } """Where a stock take is.""" enum StockTakeStatus { """ Approved: the differences were booked as INVENTORY_ADJUSTMENT stock movements (`stockTakeId`). """ APPROVED """Cancelled; nothing was booked.""" CANCELLED """Prepared; counting not started.""" DRAFT """Being counted.""" IN_PROGRESS """Counted; the differences are being reviewed.""" REVIEW } """One page of stock takes and the size of the whole list.""" type StockTakesResult { """Stock takes on this page, in the requested sort order.""" items: [StockTake!]! """Where this page is in the list and whether more pages follow.""" pageInfo: PageInfo! """ Number of items matching the filter on all pages together, not only on this one. """ totalCount: Int! } """The unit a material stock and its movements are counted in.""" enum StockUnit { """Grams, up to 3 decimals (paint).""" GRAMS """Rolls, up to 2 decimals: part of a roll counts (foil).""" ROLLS """Sheets, whole numbers (paper).""" SHEETS } """A supplier of warehouse materials.""" type Supplier { """Address of the supplier, as one text; null when not set.""" address: String """Short code of the supplier, unique, e.g. "PAP"; null when not set.""" code: String """Contact person at the supplier; null when not set.""" contactPerson: String """When the supplier was added.""" createdAt: DateTime! """Contact e-mail address; null when not set.""" email: String """Identifier of the supplier.""" id: ID! """ Whether the print shop still orders from the supplier, set in Prynt. A purchase order from an API key goes to an active supplier only. """ isActive: Boolean! """ The supplier's price list: the materials it delivers and their prices, by material name — `first` entries of it, at most 100. An empty list (never null) when it has none, or without read access to suppliers. """ materials( """ How many entries of the price list to return, by material name: 1 to 100 (100 when not given). """ first: Int! = 100 ): [SupplierMaterial!]! """Name of the supplier.""" name: String! """Tax identification number (NIP); null when not set.""" nip: String """ The print shop team's notes about the supplier, set in Prynt; null when none. """ notes: String """Contact phone number; null when not set.""" phone: String """ When the supplier or its price list (`materials`) last changed. What `updatedFrom` and the `UPDATED_AT` sort read. """ updatedAt: DateTime! } """ Conditions on suppliers: a supplier is listed when it meets every condition given. Omitted conditions do not filter. """ input SupplierFilterInput { """Suppliers whose code contains this text (case-insensitive).""" code: String """True: suppliers in use only; false: deactivated ones only.""" isActive: Boolean """Suppliers whose name contains this text (case-insensitive).""" nameContains: String """Suppliers whose tax identification number (NIP) contains this text.""" nip: String """ Only suppliers that changed at or after this moment (inclusive), as `Supplier.updatedAt` shows it. For incremental sync: pass the latest `updatedAt` you have seen, minus a few minutes, and sort by `UPDATED_AT` ascending. Null or left out: no bound (the first run of a sync reads every one). """ updatedFrom: DateTime } """ An entry of a supplier's price list: a material and the price the supplier asks for it. """ type SupplierMaterial { """Currency of the price, a 3-letter code (e.g. PLN).""" currency: String! """Identifier of the entry.""" id: ID! """When the price was last set; null when not known.""" lastPriceUpdate: DateTime """Days from order to delivery; null when not known.""" leadTimeDays: Int """ The paper, paint or foil of the warehouse (by `materialType`); null when the entry names the material only. """ materialId: ID """Name of the material, as the supplier names it.""" materialName: String! """Kind of material.""" materialType: MaterialType! """ Smallest quantity the supplier takes an order for, in the unit it sells in (not recorded in Prynt, not necessarily the stock unit); null when none. """ minimumOrderQuantity: Float """Notes about the entry; null when none.""" notes: String """The supplier.""" supplierId: ID! """ Net price of one unit as the supplier sells it, in `currency` (up to 4 decimals). Prynt does not record that unit: it is not necessarily the stock unit of the material (sheets, grams, rolls). """ unitPrice: Float! } """ What to sort suppliers by. Suppliers with equal values keep a fixed order (by identifier), so pages do not overlap. """ enum SupplierSortField { """Short code of the supplier.""" CODE """When the supplier was added.""" CREATED_AT """Name of the supplier.""" NAME """Tax identification number.""" NIP """ When the record last changed (`Supplier.updatedAt`). Ascending, with `updatedFrom`, for incremental sync. """ UPDATED_AT } """How to sort suppliers.""" input SupplierSortInput { """Ascending or descending.""" direction: SortDirection! """What to sort by.""" field: SupplierSortField! } """One page of suppliers and the size of the whole list.""" type SuppliersResult { """Suppliers on this page, in the requested sort order.""" items: [Supplier!]! """Where this page is in the list and whether more pages follow.""" pageInfo: PageInfo! """ Number of items matching the filter on all pages together, not only on this one. """ totalCount: Int! } """ A production task: the shop floor working on one operation of an order, from start to completion. An operation gets a new task each time work on it is taken up again. """ type Task { """ When the task was completed; null while it is not completed (and for a cancelled task). """ completedAt: DateTime """When the task was created.""" createdAt: DateTime! """ Status of the task now: planned (PENDING, ASSIGNED), running (IN_PROGRESS), paused, or finished (COMPLETED, CANCELLED). """ currentStatus: TaskStatus! """ When the task is due: the completion date of its order, as it was when the task was created; null when the order had none. """ dueDate: DateTime """Identifier of the task (UUID).""" id: ID! """ Identifier of the machine the task runs on (an entry of `machines`); null for a task without a machine. """ machineId: ID """ The operation the task does, with its quantities and status. Always set for an API key (which reads it with the orders scope); null for the app's other tasks. """ operation: Operation """ Identifier of the operation the task does (`Operation.id`). Always set for an API key, which sees only the tasks of operations; null for the app's other tasks. """ operationId: ID """When work on the task first started; null while it has not started.""" startedAt: DateTime """ Short name of the task, as the shop floor sees it: the operation (its description, or the machine) and the order number, for example `Druk — 1084/2026`. It names the order, so an API key reads it with the orders scope. """ title: String! """ When the task last changed: its status (started, paused, resumed, completed, cancelled) or anything else the print shop keeps on the task, including what the API does not show. Filter on it with `updatedFrom` to fetch only what changed since your last sync. """ updatedAt: DateTime! } """ Conditions on tasks: a task is listed when it meets every condition given. Omitted conditions do not filter. """ input TaskFilterInput { """Tasks on this machine (`Task.machineId`).""" machineId: ID """Tasks of this operation (`Task.operationId`).""" operationId: ID """ Tasks of the operations of this order (of every product and element in it). It points at an order, so an API key filters by it with the orders scope. """ orderId: ID """Tasks in any of these statuses.""" status: [TaskStatus!] """ Only tasks that changed at or after this moment (inclusive), as `Task.updatedAt` shows it. For incremental sync: pass the latest `updatedAt` you have seen, minus a few minutes, and sort by `UPDATED_AT` ascending. Null or left out: no bound (the first run of a sync reads every one). """ updatedFrom: DateTime } """ What to sort tasks by. Tasks with equal values keep a fixed order (by identifier), so pages do not overlap. """ enum TaskSortField { """When the task was created.""" CREATED_AT """ When the task is due (`Task.dueDate`); tasks without a due date come last when ascending, first when descending. """ DUE_DATE """ When the record last changed (`Task.updatedAt`). Ascending, with `updatedFrom`, for incremental sync. """ UPDATED_AT } """How to sort tasks.""" input TaskSortInput { """Ascending or descending.""" direction: SortDirection! """What to sort by.""" field: TaskSortField! } """ Where a production task stands: planned (PENDING, ASSIGNED), running (IN_PROGRESS), interrupted (PAUSED) or finished (COMPLETED, CANCELLED). """ enum TaskStatus { """ Planned, not started: the shop floor has taken the task on, work has not begun yet. """ ASSIGNED """ Finished without being done: the task was called off and has no completion time. """ CANCELLED """ Finished: the work is done and the task has its completion time (`completedAt`). """ COMPLETED """Running: someone is working on the task right now.""" IN_PROGRESS """ Interrupted: work started and stopped for now; it resumes as IN_PROGRESS. """ PAUSED """Planned, not started: the task waits in the queue of the shop floor.""" PENDING } """One page of tasks and the size of the whole list.""" type TasksResult { """Tasks on this page, in the requested sort order.""" items: [Task!]! """Where this page is in the list and whether more pages follow.""" pageInfo: PageInfo! """ Number of items matching the filter on all pages together, not only on this one. """ totalCount: Int! } """How an order reaches the client.""" enum TransportMethod { """Courier shipment.""" COURIER """Dedicated transport for this order.""" DEDICATED """InPost shipment.""" INPOST """Pallet shipment.""" PALLET """The client picks the order up at the print shop.""" PICKUP """Not agreed yet (the default).""" TO_BE_AGREED """The print shop's own transport.""" WE_DELIVER } """Unit of a quantity.""" enum Unit { """Impressions of a die-cutting or hot-stamping press.""" IMPRESSIONS """Kilograms.""" KG """Sets (complete kits).""" KPL """Meters.""" METER """Packages.""" PACKAGES """Pallets (packing).""" PALLETS """Passes: runs of a sheet through a printing press (calculator).""" PASSES """Pieces.""" PIECES """Printing plates (CTP).""" PLATES """Rolls.""" ROLLS """Sheets.""" SHEETS """Signatures: folded sections of a book (calculator).""" SIGNATURES } """Changes to an additional cost: fields left out keep their values.""" input UpdateAdditionalCostInput { """Net amount of the cost in the order currency, 0 or more.""" amount: Float """Kind of cost; null clears it.""" category: AdditionalCostCategory """ Longer description of the cost (up to 2000 characters); null clears it. """ description: String """True to show the cost to the client.""" isClientVisible: Boolean """Name of the cost, as shown on documents (up to 200 characters).""" name: String """Position of the cost among the costs of the order, from 0.""" sortOrder: Int """VAT rate as a fraction from 0 to 1: `0.23` for 23%.""" taxRate: Float } """ What to change in an address: a field left out keeps its value; null clears an optional field and is refused for type, name, city, street, zip and country. """ input UpdateClientAddressInput { """ Building and apartment number, for example `12A/3` (up to 20 characters). On update, null clears it. """ buildingNumber: String """City. Left out, it stays; null is refused.""" city: String """When the place closes, `HH:mm`. On update, null clears it.""" closesAt: String """Country, for example `Polska`. Left out, it stays; null is refused.""" country: String """E-mail address at the address. On update, null clears it.""" email: String """ True makes it the default address of its type (the previous default one stops being it). False when not given on create; left out on update keeps it. """ isDefault: Boolean """ Own label of the address (up to 100 characters). On update, null clears it. """ label: String """ Name at the address: the company or the person goods go to (up to 255 characters). Unique among the addresses of the client. Left out, it stays; null is refused. """ name: String """Short name (up to 100 characters). On update, null clears it.""" nameShort: String """ Remarks for deliveries (up to 2000 characters). On update, null clears it. """ notes: String """When the place opens, `HH:mm`. On update, null clears it.""" opensAt: String """ Phone number at the address (up to 15 characters). On update, null clears it. """ phone: String """Street, without the number. Left out, it stays; null is refused.""" street: String """ Code of the address type: `HEADQUARTERS`, `DELIVERY`, `WAREHOUSE`, `BILLING`, `OTHER`, or a code the print shop added. An unknown code is refused. Left out, it stays; null is refused. """ type: String """ Postal code; a Polish one must be `00-000` (`00000` is accepted and stored as `00-000`). Checked against the country after the change. Left out, it stays; null is refused. """ zip: String } """ What to change in a client: a field left out keeps its value, null clears a field that may be empty. The result must still be a valid client of its kind. """ input UpdateClientInput { """ How the client's orders are delivered by default. On update, null clears it. """ defaultDeliveryMethod: DeliveryMethod """ E-mail address of the client (up to 200 characters). On update, null clears it. """ email: String """ EU VAT identification number, for supplies within the EU (up to 20 characters). On update, null clears it. """ euVatNumber: String """ Your own identifier of the client, for example its id in your CRM or web shop (1 to 100 characters). Unique within your integration and visible only to it; find the client by it with the `externalRef` filter. Only an API key sets it. On update, null removes it. """ externalRef: String """ First name of an individual or a sole proprietor (up to 100 characters). Required, with `lastName`, for `INDIVIDUAL` and `SOLE_PROPRIETOR`. On update, null clears it. """ firstName: String """ KRS, the Polish court register number (up to 10 characters). On update, null clears it. """ krs: String """ Last name of an individual or a sole proprietor (up to 100 characters). On update, null clears it. """ lastName: String """ Legal name of a company or a sole proprietorship, as on invoices (up to 200 characters). Required for `COMPANY` and `SOLE_PROPRIETOR`. On update, null clears it. """ legalName: String """ Short name the print shop uses in lists (up to 100 characters). On update, null clears it. """ nameShort: String """ Phone number of the client, up to 15 characters: send it without spaces or brackets, for example `+48221002030`. On update, null clears it. """ phone: String """ REGON, the Polish statistical business number (up to 14 characters). On update, null clears it. """ regon: String """ Identifiers of the tags the client has (`clientTags` lists them), as a whole set: on update it replaces the current tags and an empty list removes every tag; left out, the tags stay as they are. """ tagIds: [ID!] """ Tax identification number (NIP), unique among the print shop's clients (up to 20 characters). Send digits only, for example `5213000001`: Prynt stores and finds it as sent, so `521-300-00-01` is another number. Required for `COMPANY`. On update, null clears it. """ taxIdentificationNumber: String """ Kind of client. Left out, it stays; when you change it, clear the name fields that no longer apply. """ type: ClientType } """ What to change in a note: a field left out keeps its value; null is refused. """ input UpdateClientNoteInput { """ When the contact took place. Null is refused: a note always has its date. """ contactDate: DateTime """Text of the note (up to 10000 characters).""" content: String """What the note records.""" type: ClientNoteType } """What to change on an operation: fields left out keep their values.""" input UpdateOperationInput { """ Identifier of the color profile (an entry of `referenceData(type: COLOR_PROFILE)`); null clears it. """ colorProfileId: ID """ What the operation is, in the print shop words (up to 2000 characters); null clears it. """ description: String """ Identifier of the finishing type (an entry of `referenceData(type: FINISHING_TYPE)`); null clears it. """ finishingTypeId: ID """ Identifier of the machine that does the operation (an entry of `machines`). It cannot change while a production task of the operation is planned, running or paused (`OPERATION_IN_PRODUCTION`). An API key may choose only a machine in use (`MACHINE_INACTIVE`) with a default task type (`MACHINE_NO_DEFAULT_TASK_TYPE`). """ machineId: ID """ Identifier of the operation type (an entry of `referenceData(type: OPERATION_TYPE)`); null clears it. """ operationTypeId: ID """ Net price of the whole operation (its full `quantity`, not per unit), in the order currency, 0 or more, rounded to 2 decimal places. """ price: Float """ How many units the operation processes, in `unit`: more than 0, rounded to 3 decimal places. At or below `Operation.quantityCompleted` the operation counts as completed. """ quantity: Float """ Estimated machine time per unit of `quantity`, in whole seconds, 0 or more. """ timePerUnitSeconds: Int """Unit of `quantity`.""" unit: Unit } """ Changes to an order: fields left out keep their values. An archived order cannot be changed. """ input UpdateOrderInput { """Identifier of the print shop's billing entity that invoices the order.""" billingEntityId: ID """ Identifier of the client (the print shop's customer) the order is for. The client must exist in Prynt, and an API key cannot order for a client the print shop has blocked from ordering or deactivated. """ clientId: ID """ When the order is due to be completed: an ISO 8601 date-time, or a date meaning midnight UTC at its start. """ completionDate: String """ Person to contact about the order, as a whole: fields left out are empty. On a changed order it replaces the saved contact; left out, the saved contact stays. """ contact: OrderContactInput """ Identifier of the order currency. Setting it fixes `Order.exchangeRate` at the rate of the completion date (or of today). Left out: a new order is in the print shop's home currency; a changed order keeps its currency and rate. """ currencyId: ID """ Delivery addresses, in the order to list them. On a changed order they replace all saved addresses (an empty list removes them, for example for pickup); left out, the saved addresses stay. """ deliveries: [OrderDeliveryInput!] """ Billing details for the invoice, as a whole: fields left out are empty. On a changed order they replace the saved details; left out, the saved details stay. """ invoice: OrderInvoiceInput """ True when `completionDate` is a strict deadline. Left out: false on a new order; a changed order keeps the flag. """ isDeadline: Boolean """Day by which the client should pay, as an ISO 8601 date.""" paymentDueDate: String """How the client pays.""" paymentMethod: PaymentMethod """ Where payment of the order stands. Left out: `PENDING` on a new order; a changed order keeps its payment status. """ paymentStatus: PaymentStatus """ New status of the order. Allowed: `CREATED` to `ACCEPTED` (needs a salesperson on the order), `ACCEPTED` to `IN_PRODUCTION` (needs a product with accepted files), `IN_PRODUCTION` to `READY` (every product ready), `READY` to `SENT` (a complete delivery address, a transport method other than `TO_BE_AGREED`, a prepaid order paid), `SENT` to `RECEIVED`, `CANCELLED` to `ACCEPTED` (restoring an order), and any status to `CANCELLED`. Any other change, such as a move to an earlier status, is refused. The same status again changes nothing. """ status: OrderStatus """Number of packages the whole order ships in, 0 or more.""" totalPackages: Int """Number of pallets the whole order ships on, 0 or more.""" totalPallets: Int """ How the order reaches the client. Left out: `TO_BE_AGREED` on a new order; a changed order keeps its method. """ transportMethod: TransportMethod """ Net price of transport in the order currency, 0 or more; leave it out when not charged separately. """ transportPrice: Float } """Changes to a product: fields left out keep their values.""" input UpdateProductInput { """ True when delivery must be announced to the recipient in advance (advice note). """ awizo: Boolean """Day the product is due (ISO 8601 date).""" dateDue: String """True when the product is made of FSC-certified paper.""" isFsc: Boolean """True to hide the product (it stays part of the order).""" isHidden: Boolean """ISBN or ISSN of a publication (up to 32 characters).""" isbnIssn: String """Name of the product, for example `Ulotka A5`.""" name: String """ True when the product is not to be invoiced; information for the office only. """ noInvoice: Boolean """ Position of the product within its order, from 1; must not be taken by another product of the order. """ number: Int """When the product is planned to be packed (ISO 8601).""" packingDate: String """ Net price of the whole product line (all `quantity` units together, not per unit), in the order currency, 0 or more. """ price: Float """ Net markup added to `price`, as an amount in the order currency (not a percentage), 0 or more. """ priceMarkup: Float """Print run: how many units to make, in `unit`, 0 or more.""" quantity: Float """ VAT rate in percent, from 0 to 100: `23` for 23%. A value between 0 and 1 is refused as a fraction sent by mistake (`Product.taxRate` returns the rate as a fraction: `0.23`). """ taxRate: Float """Unit of `quantity`.""" unit: Unit """Weight of the whole product line in kilograms, 0 or more.""" weight: Float } """ A change of a purchase order: a field left out keeps its value. Orders already RECEIVED or CANCELLED take no change. """ input UpdatePurchaseOrderInput { """Currency of the prices, a 3-letter code such as PLN or EUR.""" currency: String """When the delivery is expected; null clears it.""" expectedDeliveryAt: DateTime """ Your own identifier of the purchase order (see `CreatePurchaseOrderInput.externalRef`); null removes it. Changing it is your integration's bookkeeping: it does not move `PurchaseOrder.updatedAt`. """ externalRef: String """ The full item list after the change: items with `id` are changed, items without it are added (on every call: retry with `Idempotency-Key`), existing items left out are removed. An item from which goods were received cannot be removed, ordered below what was received, or (from an API key) pointed at another material or unit. """ items: [UpdatePurchaseOrderItemInput!] """Notes about the order; null clears them.""" notes: String """When the order was placed.""" orderedAt: DateTime """ The supplier the goods are ordered from; from an API key a new supplier must be active. """ supplierId: ID } """ An item in the full item list of a purchase-order change. With `id` the existing item is changed in place (what was received of it stays); without `id` it is added. """ input UpdatePurchaseOrderItemInput { """What is ordered, as the supplier names it (up to 300 characters).""" description: String! """ The existing item to change (`PurchaseOrderItem.id`); null or left out to add an item. """ id: ID """ The paper, paint or foil (by `materialType`) whose stock a delivery of this item raises; null for goods kept outside the warehouse stock. Must exist and match `materialType`. """ materialId: ID """Kind of material ordered.""" materialType: MaterialType! """A note about the item; null when none.""" notes: String """Quantity ordered, in `unit`, zero or more.""" quantity: Float! """ Unit the quantity is in, as text (up to 20 characters, compared without case). An item with a material (`materialId`) must use a unit its stock can be counted in, so a delivery lands in the stock: paper ark., ark, arkusz, arkusze, arkuszy, szt, szt., sheet, sheets (sheets); paint g, gram, grams, kg (kg x 1000 = grams); foil rolki, rolka, rolek, rol., roll, rolls, m, mb, mb. (rolls; meters are divided by `Foil.metersPerRoll`). From an API key, the unit of an item that already received goods cannot change. """ unit: String! """ Net price of one `unit`, in the currency of the purchase order (up to 4 decimals), zero or more. """ unitPrice: Float! } """A purchase order and the status to move it to.""" input UpdatePurchaseOrderStatusInput { """Identifier of the purchase order.""" id: ID! """ The new status: SENT (from DRAFT or CONFIRMED), CONFIRMED (from SENT) or CANCELLED (from any status before RECEIVED). PARTIALLY_RECEIVED and RECEIVED follow from deliveries (`receivePurchaseOrder`). The current status again changes nothing. """ status: PurchaseOrderStatus! } """ A change of a supplier: a field left out keeps its value; null clears an optional field. """ input UpdateSupplierInput { """Address of the supplier; null clears it.""" address: String """Short code of the supplier, unique; null clears it.""" code: String """Contact person at the supplier; null clears it.""" contactPerson: String """Contact e-mail address; null clears it.""" email: String """Name of the supplier (1 to 200 characters); cannot be null.""" name: String """Tax identification number (NIP); null clears it.""" nip: String """Contact phone number; null clears it.""" phone: String } """ A VAT rate the print shop uses: what `Product.taxRate` and `ProductInvoice.vatRate` hold. """ type VatRate { """Identifier of the rate (UUID).""" id: ID! """ False when the print shop no longer offers the rate (older records may still use it). """ isActive: Boolean! """True for the rate a new product gets by default.""" isDefault: Boolean! """Name of the rate in the print shop, for example `23%`.""" name: String! """The rate as a fraction, for example `0.23` for 23%.""" rate: Float! """Position of the rate in the print shop lists, from 0.""" sortOrder: Int! } """ An issue of foil from stock: the sheets cut from the roll, what for and why. The stock in rolls drops by sheets x sheet length / meters per roll (`Foil.metersPerRoll`). """ input WithdrawFoilInput { """ The element the material is issued for; it must belong to `productId` (and `orderId`) when given. The movement records its product and order too. """ elementId: ID """A note about the issue, up to 2000 characters.""" notes: String """Sheets of foil cut from the roll: a whole number, at least 1.""" numberOfSheets: Int! """ The operation the material is issued for; it must belong to `elementId` (and the product and order) when given. The movement records its element, product and order too, so the movement filters by any of them find it. """ operationId: ID """ The order the material is issued for: it must exist. From an API key, that order — given here or reached through `productId`, `elementId` or `operationId` — must not be archived. `warehouse:write` may name any order: the movement refers to it by its id only (`StockMovement.orderId`). """ orderId: ID """ The product the material is issued for; it must belong to `orderId` when both are given. The movement records its order too (`StockMovement.orderId`). """ productId: ID """ Length of one sheet in millimeters, above zero. An issue that takes more rolls than the stock holds, or one of a foil without meters per roll, is refused with STOCK_INSUFFICIENT or STOCK_UNIT_NOT_CONVERTIBLE. """ sheetLengthMm: Float! """Why the foil leaves the stock. Default PRODUCTION.""" withdrawalType: WithdrawalType } """ An issue of paint from stock: the grams taken, what for and why. The stock drops by the grams taken and never below zero. """ input WithdrawPaintInput { """ The element the material is issued for; it must belong to `productId` (and `orderId`) when given. The movement records its product and order too. """ elementId: ID """A note about the issue, up to 2000 characters.""" notes: String """ The operation the material is issued for; it must belong to `elementId` (and the product and order) when given. The movement records its element, product and order too, so the movement filters by any of them find it. """ operationId: ID """ The order the material is issued for: it must exist. From an API key, that order — given here or reached through `productId`, `elementId` or `operationId` — must not be archived. `warehouse:write` may name any order: the movement refers to it by its id only (`StockMovement.orderId`). """ orderId: ID """ The product the material is issued for; it must belong to `orderId` when both are given. The movement records its order too (`StockMovement.orderId`). """ productId: ID """ Grams taken from stock — always give it: above zero (kept to 0.001 g) and at most the stock (`Paint.quantityGrams`); more is refused with STOCK_INSUFFICIENT. """ quantity: Float """Why the paint leaves the stock. Default PRODUCTION.""" withdrawalType: WithdrawalType } """ An issue of paper from stock: the sheets taken, what for and why. The stock drops by the sheets taken and never below zero. An issue for an order also fulfils the active reservations of this paper for that order (of `elementId`, when given). """ input WithdrawPaperInput { """ The element the material is issued for; it must belong to `productId` (and `orderId`) when given. The movement records its product and order too. """ elementId: ID """ True: FSC-certified paper is issued, so the FSC stock (`Paper.fscQuantitySheets`) drops by the same sheets; refused when the FSC stock holds fewer, and from an API key when the paper is not FSC-certified (`Paper.isFsc` false). Default false. """ isFsc: Boolean """A note about the issue, up to 2000 characters.""" notes: String """ The operation the material is issued for; it must belong to `elementId` (and the product and order) when given. The movement records its element, product and order too, so the movement filters by any of them find it. """ operationId: ID """ The order the material is issued for: it must exist. From an API key, that order — given here or reached through `productId`, `elementId` or `operationId` — must not be archived. `warehouse:write` may name any order: the movement refers to it by its id only (`StockMovement.orderId`). """ orderId: ID """ The product the material is issued for; it must belong to `orderId` when both are given. The movement records its order too (`StockMovement.orderId`). """ productId: ID """ Sheets taken from stock — always give it: a whole number above zero and at most the stock (`Paper.quantitySheets`); more is refused with STOCK_INSUFFICIENT. """ quantity: Float """Why the paper leaves the stock. Default PRODUCTION.""" withdrawalType: WithdrawalType } """Why material leaves the warehouse stock in an issue.""" enum WithdrawalType { """A correction of the recorded stock.""" CORRECTION """Any other reason.""" OTHER """Used in production.""" PRODUCTION """Returned to the supplier.""" RETURN """Wasted or damaged.""" WASTE }