@openmrp/sdk 0.19.3

package/resources/operations/production-schedules/actions.d.mts

@@ -0,0 +1,890 @@
+import { APIResource } from "../../../core/resource.mjs";
+import * as CoreAPI from "../../core/core.mjs";
+import * as APIKeysAPI from "../../auth/api-keys/api-keys.mjs";
+import * as ProductionSchedulesAPI from "./production-schedules.mjs";
+import * as SalesOrdersActionsAPI from "../../sales/sales-orders/actions.mjs";
+import { APIPromise } from "../../../core/api-promise.mjs";
+import { RequestOptions } from "../../../internal/request-options.mjs";
+/**
+ * Generate and review machine-level production schedules.
+ */
+export declare class Actions extends APIResource {
+    /**
+     * Runs the production scheduling solver and returns the plan without saving it.
+     *
+     * This is the inspection surface for the scheduler: it takes the same path a
+     * generated schedule will take, minus the write, so a plan can be reviewed and
+     * compared before anything depends on it. No version is created and nothing is
+     * numbered, so this can be called as often as needed.
+     *
+     * The solver plans the constraint department — the room that sets the pace of the
+     * factory — so production schedule settings must name one and it must have
+     * machines that are included in planning. Without that there is nothing to
+     * schedule and the request is rejected rather than returning an empty plan.
+     *
+     * This endpoint requires the permission: `production_schedules:read`.
+     *
+     * @example
+     * ```ts
+     * const productionSchedulePreview =
+     *   await client.operations.productionSchedules.actions.preview(
+     *     { horizon_weeks: 13 },
+     *   );
+     * ```
+     */
+    preview(body?: ActionPreviewParams | null | undefined, options?: RequestOptions): APIPromise<ProductionSchedulePreview>;
+    /**
+     * Returns what regenerating this draft would change, without changing it.
+     *
+     * Every campaign either plan holds is listed, including the ones both agree on, so
+     * the caller can render a full side-by-side rather than a list of surprises. Only
+     * a draft can be previewed, for the same reason only a draft can be regenerated.
+     *
+     * The comparison is run the way a regenerate runs by default — hand-edited
+     * campaigns are kept, and the fresh solve plans around them — so they read as
+     * unchanged rather than as work the solver wants to take away. `manual_line_count`
+     * is how many campaigns on the draft were placed or edited by hand, which is the
+     * work a `replace_all` regenerate is putting at risk.
+     *
+     * The horizon and demand basis default to the ones this version already has, so a
+     * plain call changes only how current the plan is, not what question is being
+     * asked.
+     *
+     * This endpoint requires the permission: `production_schedules:read`.
+     *
+     * @example
+     * ```ts
+     * const productionScheduleRegeneratePreview =
+     *   await client.operations.productionSchedules.actions.previewRegenerate(
+     *     'pnsc_m4zt3z8g8src',
+     *     { horizon_weeks: 13 },
+     *   );
+     * ```
+     */
+    previewRegenerate(id: string, body?: ActionPreviewRegenerateParams | null | undefined, options?: RequestOptions): APIPromise<ProductionScheduleRegeneratePreview>;
+    /**
+     * Re-solves a draft in place, keeping its version number.
+     *
+     * Only a draft can be regenerated. A published version is a commitment the floor
+     * is already working to, and a superseded or archived one is history; re-solving
+     * either in place would change what a week was measured against after the fact. To
+     * replan against a published version, generate a new one — publishing it
+     * supersedes the current one.
+     *
+     * The version number is kept deliberately: minting a new version for every
+     * re-solve would fill the list with drafts nobody asked for and make the version
+     * number meaningless as a count of the plans actually considered.
+     *
+     * Every hand edit a `replace_all` destroys is written to the deviation log before
+     * it goes, so "where did my change go" stays answerable. Call `preview-regenerate`
+     * first to see what a re-solve would change.
+     *
+     * Aside from the hand edits a `preserve_manual` run keeps, the version's
+     * campaigns, policy snapshot, derived department work, solver diagnostics and
+     * settings snapshot are all replaced with the fresh solve's, so the plan can still
+     * explain itself afterwards.
+     *
+     * This endpoint requires the permission: `production_schedules:update`.
+     *
+     * @example
+     * ```ts
+     * const productionSchedule =
+     *   await client.operations.productionSchedules.actions.regenerate(
+     *     'pnsc_m4zt3z8g8src',
+     *     { merge_mode: 'preserve_manual' },
+     *   );
+     * ```
+     */
+    regenerate(id: string, body?: ActionRegenerateParams | null | undefined, options?: RequestOptions): APIPromise<ProductionSchedulesAPI.ProductionSchedule>;
+    /**
+     * Publishes a draft schedule, freezing its first weeks.
+     *
+     * Publishing is what makes a plan a commitment: the frozen weeks' lines are marked
+     * frozen, the frozen line count and quantity are captured onto the version, and
+     * any published version whose horizon overlaps this one's is superseded rather
+     * than rewritten. After this, a change inside the frozen window has to state a
+     * reason.
+     *
+     * Only a draft can be published. How many weeks freeze comes from the account's
+     * frozen-weeks setting as it stood when the version was generated, and a version
+     * generated with zero frozen weeks publishes without committing to anything.
+     *
+     * The frozen counts are snapshotted here and never recomputed, so adherence keeps
+     * the denominator it was committed to.
+     *
+     * This endpoint requires the permission: `production_schedules:update`.
+     *
+     * @example
+     * ```ts
+     * const productionSchedule =
+     *   await client.operations.productionSchedules.actions.publish(
+     *     'pnsc_m4zt3z8g8src',
+     *   );
+     * ```
+     */
+    publish(id: string, options?: RequestOptions): APIPromise<ProductionSchedulesAPI.ProductionSchedule>;
+    /**
+     * Turns one planned week into a production run.
+     *
+     * Each campaign in the week becomes one batch per planned lot, using the lot size
+     * the campaign was planned at. A 360-unit campaign at a 60-unit lot arrives on the
+     * floor as six batches, not one instruction to make 360; a quantity that is not a
+     * whole number of lots trails a single short lot at the end of the run.
+     *
+     * The release is atomic. A run holding half a week's batches is worse than no run,
+     * because the missing half looks like work nobody was asked to do and attainment
+     * would count it as unplanned production.
+     *
+     * Releasing the same week twice fails rather than creating a second run. Each
+     * released line records the run now carrying it, and a line that is already
+     * released is never re-pointed.
+     *
+     * Lots an earlier week already issued are carried forward rather than reissued.
+     * When a week fell short, the next plan asks for the shortfall — and the batches
+     * covering it are usually already printed and sitting on the floor. Those tickets
+     * are moved into this run and counted against the campaign, so only the genuinely
+     * new work is created. `carried_forward_batch_count` says how many arrived that
+     * way, and each one names the run it came off. Send `skip_carry_forward` to issue
+     * the whole week new instead.
+     *
+     * Cancelled campaigns and campaigns planned at zero are left behind rather than
+     * released. A week that would produce an implausible number of batches is rejected
+     * outright, since that is far more likely to be a misconfigured lot size than a
+     * real week's work.
+     *
+     * This endpoint requires the permissions: `production_schedules:update`,
+     * `production_runs:create`.
+     *
+     * @example
+     * ```ts
+     * const releaseScheduleWeekResult =
+     *   await client.operations.productionSchedules.actions.releaseWeek(
+     *     'pnsc_m4zt3z8g8src',
+     *     {
+     *       responsible_user_id: 'us_43irtlt2ajz6',
+     *       week_index: 0,
+     *     },
+     *   );
+     * ```
+     */
+    releaseWeek(id: string, body: ActionReleaseWeekParams, options?: RequestOptions): APIPromise<ReleaseScheduleWeekResult>;
+    /**
+     * Archives a schedule version, retiring it without discarding its history.
+     *
+     * Any version that is not already archived can be archived, including a draft that
+     * was never published. The version stays readable — its campaigns, policy snapshot
+     * and deviation log are kept — and it still backs any attainment already measured
+     * against it.
+     *
+     * Archiving does not supersede anything or promote another version in its place.
+     * To take a published version out of use by replacing it, generate and publish a
+     * newer one instead.
+     *
+     * This endpoint requires the permission: `production_schedules:update`.
+     *
+     * @example
+     * ```ts
+     * const productionSchedule =
+     *   await client.operations.productionSchedules.actions.archive(
+     *     'pnsc_m4zt3z8g8src',
+     *   );
+     * ```
+     */
+    archive(id: string, options?: RequestOptions): APIPromise<ProductionSchedulesAPI.ProductionSchedule>;
+}
+/**
+ * A single page of resources, together with the metadata needed to page through
+ * the rest of the result set.
+ */
+export interface ListScheduleCampaign {
+    /**
+     * Resources in this page.
+     */
+    data: Array<ScheduleCampaign>;
+    /**
+     * Resource type identifier.
+     */
+    object: 'list';
+    /**
+     * PageInfo describes where the current page sits within a paginated result set and
+     * how to move to the adjacent pages.
+     *
+     * Page a list by following the URLs below rather than assembling cursors yourself.
+     * For a top-level list endpoint the URL repeats the original request's query
+     * string with only the cursor swapped, so following it preserves the same filters,
+     * search term, and page size.
+     */
+    page_info: APIKeysAPI.PageInfo;
+}
+/**
+ * A single page of resources, together with the metadata needed to page through
+ * the rest of the result set.
+ */
+export interface ListScheduleDiffLine {
+    /**
+     * Resources in this page.
+     */
+    data: Array<ScheduleDiffLine>;
+    /**
+     * Resource type identifier.
+     */
+    object: 'list';
+    /**
+     * PageInfo describes where the current page sits within a paginated result set and
+     * how to move to the adjacent pages.
+     *
+     * Page a list by following the URLs below rather than assembling cursors yourself.
+     * For a top-level list endpoint the URL repeats the original request's query
+     * string with only the cursor swapped, so following it preserves the same filters,
+     * search term, and page size.
+     */
+    page_info: APIKeysAPI.PageInfo;
+}
+/**
+ * A single page of resources, together with the metadata needed to page through
+ * the rest of the result set.
+ */
+export interface ListSchedulePolicy {
+    /**
+     * Resources in this page.
+     */
+    data: Array<SchedulePolicy>;
+    /**
+     * Resource type identifier.
+     */
+    object: 'list';
+    /**
+     * PageInfo describes where the current page sits within a paginated result set and
+     * how to move to the adjacent pages.
+     *
+     * Page a list by following the URLs below rather than assembling cursors yourself.
+     * For a top-level list endpoint the URL repeats the original request's query
+     * string with only the cursor swapped, so following it preserves the same filters,
+     * search term, and page size.
+     */
+    page_info: APIKeysAPI.PageInfo;
+}
+/**
+ * A single page of resources, together with the metadata needed to page through
+ * the rest of the result set.
+ */
+export interface ListScheduleProjection {
+    /**
+     * Resources in this page.
+     */
+    data: Array<ScheduleProjection>;
+    /**
+     * Resource type identifier.
+     */
+    object: 'list';
+    /**
+     * PageInfo describes where the current page sits within a paginated result set and
+     * how to move to the adjacent pages.
+     *
+     * Page a list by following the URLs below rather than assembling cursors yourself.
+     * For a top-level list endpoint the URL repeats the original request's query
+     * string with only the cursor swapped, so following it preserves the same filters,
+     * search term, and page size.
+     */
+    page_info: APIKeysAPI.PageInfo;
+}
+/**
+ * Request to preview a production schedule.
+ */
+export interface PreviewProductionScheduleRequest {
+    /**
+     * How future demand is derived, overriding the account's configured basis for this
+     * preview only.
+     *
+     * - `trailing_12`: demand is the trailing twelve months of orders.
+     * - `seasonal_ema`: demand is a seasonal exponential moving average, which follows
+     *   a season arriving early or late rather than flattening it.
+     */
+    demand_basis?: 'trailing_12' | 'seasonal_ema';
+    /**
+     * Number of weeks the plan should cover, overriding the account's configured
+     * horizon for this preview only.
+     */
+    horizon_weeks?: number;
+    /**
+     * The instant to plan against, which is what stock, demand history and active
+     * demand overrides are read as of.
+     *
+     * Left unset, the preview is solved against the moment the request arrives. The
+     * horizon starts on the account's configured week-start day on or before this
+     * instant, so backdating this shifts the whole week grid.
+     */
+    planning_as_of?: string;
+}
+/**
+ * Request to see what a re-solve would change.
+ */
+export interface PreviewRegenerateProductionScheduleRequest {
+    /**
+     * How future demand is derived, defaulting to the basis this version was solved
+     * with.
+     *
+     * - `trailing_12`: demand is the trailing twelve months of orders.
+     * - `seasonal_ema`: demand is a seasonal exponential moving average, which follows
+     *   a season arriving early or late rather than flattening it.
+     */
+    demand_basis?: 'trailing_12' | 'seasonal_ema';
+    /**
+     * Number of weeks the re-solve should cover, defaulting to the horizon this
+     * version already has.
+     */
+    horizon_weeks?: number;
+    /**
+     * The instant to plan against, which is what stock, demand history and active
+     * demand overrides are read as of.
+     *
+     * Defaults to now rather than to the instant the version was first generated, so a
+     * plain call answers "what would the solver say today". Because the horizon
+     * re-anchors to the week containing this instant, a campaign can appear under a
+     * different `week_index` than the one stored on the draft.
+     */
+    planning_as_of?: string;
+}
+/**
+ * A production plan produced by the scheduling solver.
+ */
+export interface ProductionSchedulePreview {
+    /**
+     * A single page of resources, together with the metadata needed to page through
+     * the rest of the result set.
+     */
+    campaigns: ListScheduleCampaign | null;
+    /**
+     * What the solver could not do, and why the plan differs from raw history.
+     */
+    diagnostics: ProductionSchedulesAPI.ScheduleDiagnostics;
+    /**
+     * Resource type identifier.
+     */
+    object: 'production_schedule_preview';
+    /**
+     * The instant the plan was calculated against.
+     */
+    planning_as_of_at: string;
+    /**
+     * A single page of resources, together with the metadata needed to page through
+     * the rest of the result set.
+     */
+    policies: ListSchedulePolicy | null;
+    /**
+     * A single page of resources, together with the metadata needed to page through
+     * the rest of the result set.
+     */
+    projections: ListScheduleProjection | null;
+    /**
+     * Version of the solver that produced this plan.
+     */
+    solver_version: string;
+}
+/**
+ * What a regenerate would change about a draft, without changing it.
+ *
+ * A regenerate that silently discards hand-work is abandoned within two cycles, so
+ * the destructive mode states its cost as a number before it runs:
+ * `discarded_manual_count` is exactly how many hand-edited campaigns `replace_all`
+ * would destroy.
+ */
+export interface ProductionScheduleRegeneratePreview {
+    /**
+     * Campaigns the fresh solve wants that the current plan does not have.
+     */
+    added_count: number;
+    /**
+     * Campaigns both hold, in different quantities.
+     */
+    changed_count: number;
+    /**
+     * Hand-edited campaigns `replace_all` would destroy.
+     */
+    discarded_manual_count: number;
+    /**
+     * A single page of resources, together with the metadata needed to page through
+     * the rest of the result set.
+     */
+    lines: ListScheduleDiffLine | null;
+    /**
+     * Hand-edited campaigns currently on the draft.
+     */
+    manual_line_count: number;
+    /**
+     * Resource type identifier.
+     */
+    object: 'production_schedule_regenerate_preview';
+    /**
+     * The instant the fresh solve planned from.
+     *
+     * Unless the caller names an instant, a regenerate plans from now rather than
+     * replaying the one the draft was first generated against, so demand overrides
+     * added since then are taken into account and the horizon re-anchors to today.
+     */
+    planning_as_of_at: string;
+    /**
+     * Entity is a polymorphic reference to any resource in the system.
+     */
+    production_schedule: CoreAPI.Entity | null;
+    /**
+     * Campaigns the current plan has that the fresh solve does not want.
+     */
+    removed_count: number;
+    /**
+     * Which solver produced the proposal.
+     */
+    solver_version: string;
+}
+/**
+ * Request to re-solve a draft in place.
+ */
+export interface RegenerateProductionScheduleRequest {
+    /**
+     * How future demand is derived, defaulting to the basis this version was solved
+     * with.
+     *
+     * - `trailing_12`: demand is the trailing twelve months of orders.
+     * - `seasonal_ema`: demand is a seasonal exponential moving average, which follows
+     *   a season arriving early or late rather than flattening it.
+     */
+    demand_basis?: 'trailing_12' | 'seasonal_ema';
+    /**
+     * Number of weeks the re-solve should cover, defaulting to the horizon this
+     * version already has.
+     */
+    horizon_weeks?: number;
+    /**
+     * What happens to the campaigns someone placed or edited by hand.
+     *
+     * - `preserve_manual`: hand-edited campaigns are kept, and the fresh solve plans
+     *   around them — their stock and machine time are facts the rest of the plan
+     *   responds to.
+     * - `replace_all`: hand edits are discarded and the fresh solve is taken whole.
+     *
+     * Omitting this keeps hand edits, because the alternative destroys work silently.
+     */
+    merge_mode?: 'preserve_manual' | 'replace_all';
+    /**
+     * The instant to plan against, which is what stock, demand history and active
+     * demand overrides are read as of.
+     *
+     * Defaults to now rather than to the instant the version was first generated, so a
+     * plain call answers "what would the solver say today". Because the horizon
+     * re-anchors to the week containing this instant, a kept campaign keeps the
+     * calendar week it was planned in but can end up under a different `week_index`.
+     */
+    planning_as_of?: string;
+}
+/**
+ * Request to release one week of a production schedule to the floor.
+ */
+export interface ReleaseProductionScheduleWeekRequest {
+    /**
+     * ID of the account user accountable for executing the run.
+     *
+     * Accepts either an account user ID or a user ID; it is resolved and stored as the
+     * account user.
+     */
+    responsible_user_id: string;
+    /**
+     * Zero-based week offset from the start of the horizon.
+     */
+    week_index: number;
+    /**
+     * ID of the scanning station the batches will be scanned at.
+     *
+     * Applied to every batch this release creates, across all machines in the week.
+     */
+    scanning_station_id?: string;
+    /**
+     * Issue the whole week as new batches, leaving an earlier week's unworked lots
+     * where they are.
+     *
+     * Off unless you ask for it: reprinting a ticket the floor is already holding is
+     * exactly what carrying work forward exists to prevent, so it takes a deliberate
+     * choice to do it.
+     */
+    skip_carry_forward?: boolean;
+}
+/**
+ * The production run created from one week of a schedule.
+ *
+ * Each planned campaign becomes one batch per lot, so a 360-unit week at a 60-unit
+ * lot arrives on the floor as six batches rather than one instruction to make 360.
+ */
+export interface ReleaseScheduleWeekResult {
+    /**
+     * How many batches the run holds across all campaigns, created and carried forward
+     * together.
+     */
+    batch_count: number;
+    /**
+     * How many of `batch_count` were moved off an earlier run rather than created.
+     *
+     * Tickets for these are already printed and on the floor.
+     */
+    carried_forward_batch_count: number;
+    /**
+     * A single page of resources, together with the metadata needed to page through
+     * the rest of the result set.
+     */
+    lines: ProductionSchedulesAPI.ListReleasedScheduleLine | null;
+    /**
+     * Resource type identifier.
+     */
+    object: 'production_schedule_week_release';
+    /**
+     * A production run: the group of shop-floor batches that are executed together,
+     * tracked from the first batch scan through to completion.
+     */
+    production_run: SalesOrdersActionsAPI.ProductionRun | null;
+    /**
+     * How many campaigns were released.
+     */
+    released_line_count: number;
+    /**
+     * Total units released.
+     */
+    total_quantity: number;
+    /**
+     * Zero-based week offset from the start of the horizon.
+     */
+    week_index: number;
+    /**
+     * First instant of the released week.
+     */
+    week_starts_at: string;
+}
+/**
+ * One planned production block: make this item, on this machine, in this week.
+ */
+export interface ScheduleCampaign {
+    /**
+     * Entity is a polymorphic reference to any resource in the system.
+     */
+    item: CoreAPI.Entity | null;
+    /**
+     * Whole lots the quantity rounds to.
+     */
+    lots: number;
+    /**
+     * Entity is a polymorphic reference to any resource in the system.
+     */
+    machine: CoreAPI.Entity | null;
+    /**
+     * Constraint hours the campaign consumes.
+     */
+    run_hours: number;
+    /**
+     * SKU of the item.
+     */
+    sku: string;
+    /**
+     * Quantity to produce.
+     */
+    units: number;
+    /**
+     * Zero-based week offset from the start of the horizon.
+     */
+    week_index: number;
+}
+/**
+ * One campaign as the current plan and a fresh solve each see it.
+ */
+export interface ScheduleDiffLine {
+    /**
+     * What the regenerate would do to this campaign.
+     *
+     * - `added`: the fresh solve wants a campaign the current plan does not have.
+     * - `removed`: the current plan holds a campaign the fresh solve does not want.
+     * - `changed`: both hold the campaign, in different quantities.
+     * - `unchanged`: both agree on it.
+     */
+    change: 'added' | 'removed' | 'changed' | 'unchanged';
+    /**
+     * Whether the current campaign was created or edited by a person.
+     */
+    current_is_manual: boolean;
+    /**
+     * Units the current plan asks for.
+     *
+     * Zero when the campaign is being added.
+     */
+    current_quantity: number;
+    /**
+     * Entity is a polymorphic reference to any resource in the system.
+     */
+    item: CoreAPI.Entity | null;
+    /**
+     * Entity is a polymorphic reference to any resource in the system.
+     */
+    machine: CoreAPI.Entity | null;
+    /**
+     * Units the fresh solve asks for.
+     *
+     * Zero when the campaign is being removed.
+     */
+    proposed_quantity: number;
+    /**
+     * SKU of that item.
+     */
+    sku: string;
+    /**
+     * Zero-based horizon week.
+     */
+    week_index: number;
+}
+/**
+ * The inventory policy computed for one item.
+ */
+export interface SchedulePolicy {
+    /**
+     * ABC class by share of constraint run hours.
+     *
+     * - `a`: consumes the largest share of constraint capacity.
+     * - `b`: moderate constraint consumption.
+     * - `c`: consumes little constraint capacity.
+     */
+    abc_class: 'a' | 'b' | 'c' | null;
+    /**
+     * Demand used for planning, annualized.
+     */
+    annual_demand: number;
+    /**
+     * Constraint hours this item's annual demand consumes.
+     */
+    annual_run_hours: number;
+    /**
+     * What the constraint stage holds on average: its buffer plus half a campaign.
+     */
+    average_greige_inventory: number;
+    /**
+     * Observed or default lead time at the constraint.
+     */
+    constraint_lead_time_weeks: number;
+    /**
+     * Economic order quantity: the campaign size that balances the cost of a
+     * changeover against the cost of holding what it produces.
+     */
+    eoq_units: number;
+    /**
+     * Lead time from the constraint to sellable stock.
+     */
+    finish_lead_time_weeks: number;
+    /**
+     * Outstanding quantity the order book already owed for this item over the horizon.
+     */
+    firm_demand_units: number;
+    /**
+     * Quantity the forecast projected for the same window.
+     */
+    forecast_demand_units: number;
+    /**
+     * How this item was planned.
+     *
+     * - `make_to_stock`: built to the forecast, holding a safety stock against its
+     *   variability.
+     * - `make_to_order`: built only against orders already on the book, holding no
+     *   buffer, so its safety stocks and reorder point are all zero.
+     */
+    fulfillment_policy: 'make_to_stock' | 'make_to_order';
+    /**
+     * Annual cost of holding one unit.
+     */
+    holding_cost: number;
+    /**
+     * Entity is a polymorphic reference to any resource in the system.
+     */
+    item: CoreAPI.Entity | null;
+    /**
+     * What the constraint stage holds at its peak: its buffer plus a whole campaign.
+     */
+    max_greige_inventory: number;
+    /**
+     * Stock on hand at the constraint plus everything downstream of it.
+     */
+    on_hand_echelon: number;
+    /**
+     * Stock sitting at the constraint stage on its own.
+     */
+    on_hand_greige: number;
+    /**
+     * Ceiling on how far ahead this item is built.
+     */
+    order_up_to: number;
+    /**
+     * Which rule decided that policy: the item itself, its product line, or the
+     * account default.
+     */
+    policy_source: 'item' | 'product_line' | 'account_default';
+    /**
+     * Stock position at which a campaign is triggered.
+     */
+    reorder_point: number;
+    /**
+     * Buffer held as finished goods.
+     */
+    safety_stock_downstream: number;
+    /**
+     * Buffer held at the constraint, pooled across the finished goods it feeds.
+     */
+    safety_stock_primary: number;
+    /**
+     * How long one unit occupies the constraint.
+     */
+    seconds_per_unit: number;
+    /**
+     * Cost of one changeover, used as the setup cost in the lot-size calculation.
+     */
+    setup_cost: number;
+    /**
+     * SKU of the item.
+     */
+    sku: string;
+    /**
+     * Standard cost per unit.
+     */
+    unit_cost: number;
+    /**
+     * Demand used for planning, per week.
+     */
+    weekly_demand: number;
+    /**
+     * Weeks of demand the current stock covers.
+     */
+    weeks_of_cover: number;
+}
+/**
+ * An item's projected stock position across the horizon.
+ */
+export interface ScheduleProjection {
+    /**
+     * Entity is a polymorphic reference to any resource in the system.
+     */
+    item: CoreAPI.Entity | null;
+    /**
+     * Projected stock at the end of each week of the horizon.
+     */
+    on_hand_by_week: Array<number>;
+}
+export interface ActionPreviewParams {
+    /**
+     * How future demand is derived, overriding the account's configured basis for this
+     * preview only.
+     *
+     * - `trailing_12`: demand is the trailing twelve months of orders.
+     * - `seasonal_ema`: demand is a seasonal exponential moving average, which follows
+     *   a season arriving early or late rather than flattening it.
+     */
+    demand_basis?: 'trailing_12' | 'seasonal_ema';
+    /**
+     * Number of weeks the plan should cover, overriding the account's configured
+     * horizon for this preview only.
+     */
+    horizon_weeks?: number;
+    /**
+     * The instant to plan against, which is what stock, demand history and active
+     * demand overrides are read as of.
+     *
+     * Left unset, the preview is solved against the moment the request arrives. The
+     * horizon starts on the account's configured week-start day on or before this
+     * instant, so backdating this shifts the whole week grid.
+     */
+    planning_as_of?: string;
+}
+export interface ActionPreviewRegenerateParams {
+    /**
+     * How future demand is derived, defaulting to the basis this version was solved
+     * with.
+     *
+     * - `trailing_12`: demand is the trailing twelve months of orders.
+     * - `seasonal_ema`: demand is a seasonal exponential moving average, which follows
+     *   a season arriving early or late rather than flattening it.
+     */
+    demand_basis?: 'trailing_12' | 'seasonal_ema';
+    /**
+     * Number of weeks the re-solve should cover, defaulting to the horizon this
+     * version already has.
+     */
+    horizon_weeks?: number;
+    /**
+     * The instant to plan against, which is what stock, demand history and active
+     * demand overrides are read as of.
+     *
+     * Defaults to now rather than to the instant the version was first generated, so a
+     * plain call answers "what would the solver say today". Because the horizon
+     * re-anchors to the week containing this instant, a campaign can appear under a
+     * different `week_index` than the one stored on the draft.
+     */
+    planning_as_of?: string;
+}
+export interface ActionRegenerateParams {
+    /**
+     * How future demand is derived, defaulting to the basis this version was solved
+     * with.
+     *
+     * - `trailing_12`: demand is the trailing twelve months of orders.
+     * - `seasonal_ema`: demand is a seasonal exponential moving average, which follows
+     *   a season arriving early or late rather than flattening it.
+     */
+    demand_basis?: 'trailing_12' | 'seasonal_ema';
+    /**
+     * Number of weeks the re-solve should cover, defaulting to the horizon this
+     * version already has.
+     */
+    horizon_weeks?: number;
+    /**
+     * What happens to the campaigns someone placed or edited by hand.
+     *
+     * - `preserve_manual`: hand-edited campaigns are kept, and the fresh solve plans
+     *   around them — their stock and machine time are facts the rest of the plan
+     *   responds to.
+     * - `replace_all`: hand edits are discarded and the fresh solve is taken whole.
+     *
+     * Omitting this keeps hand edits, because the alternative destroys work silently.
+     */
+    merge_mode?: 'preserve_manual' | 'replace_all';
+    /**
+     * The instant to plan against, which is what stock, demand history and active
+     * demand overrides are read as of.
+     *
+     * Defaults to now rather than to the instant the version was first generated, so a
+     * plain call answers "what would the solver say today". Because the horizon
+     * re-anchors to the week containing this instant, a kept campaign keeps the
+     * calendar week it was planned in but can end up under a different `week_index`.
+     */
+    planning_as_of?: string;
+}
+export interface ActionReleaseWeekParams {
+    /**
+     * ID of the account user accountable for executing the run.
+     *
+     * Accepts either an account user ID or a user ID; it is resolved and stored as the
+     * account user.
+     */
+    responsible_user_id: string;
+    /**
+     * Zero-based week offset from the start of the horizon.
+     */
+    week_index: number;
+    /**
+     * ID of the scanning station the batches will be scanned at.
+     *
+     * Applied to every batch this release creates, across all machines in the week.
+     */
+    scanning_station_id?: string;
+    /**
+     * Issue the whole week as new batches, leaving an earlier week's unworked lots
+     * where they are.
+     *
+     * Off unless you ask for it: reprinting a ticket the floor is already holding is
+     * exactly what carrying work forward exists to prevent, so it takes a deliberate
+     * choice to do it.
+     */
+    skip_carry_forward?: boolean;
+}
+export declare namespace Actions {
+    export { type ListScheduleCampaign as ListScheduleCampaign, type ListScheduleDiffLine as ListScheduleDiffLine, type ListSchedulePolicy as ListSchedulePolicy, type ListScheduleProjection as ListScheduleProjection, type PreviewProductionScheduleRequest as PreviewProductionScheduleRequest, type PreviewRegenerateProductionScheduleRequest as PreviewRegenerateProductionScheduleRequest, type ProductionSchedulePreview as ProductionSchedulePreview, type ProductionScheduleRegeneratePreview as ProductionScheduleRegeneratePreview, type RegenerateProductionScheduleRequest as RegenerateProductionScheduleRequest, type ReleaseProductionScheduleWeekRequest as ReleaseProductionScheduleWeekRequest, type ReleaseScheduleWeekResult as ReleaseScheduleWeekResult, type ScheduleCampaign as ScheduleCampaign, type ScheduleDiffLine as ScheduleDiffLine, type SchedulePolicy as SchedulePolicy, type ScheduleProjection as ScheduleProjection, type ActionPreviewParams as ActionPreviewParams, type ActionPreviewRegenerateParams as ActionPreviewRegenerateParams, type ActionRegenerateParams as ActionRegenerateParams, type ActionReleaseWeekParams as ActionReleaseWeekParams, };
+}
+//# sourceMappingURL=actions.d.mts.map