> ## Documentation Index
> Fetch the complete documentation index at: https://docs.assetinfinity.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Change capex proposals' capitalization plans and their lots from a spreadsheet, a proposal at a time, or say what stops…

> Change capex proposals' capitalization plans and their lots from a spreadsheet, a proposal at a time, or say what stops each one.

p_payload is {"plans": [...], "lines": [...]}, a row of the file each, at most 2,000 to a list. Every row names its proposal by scheme_code, the Request ID, among the capitalization plans you can see; a plan is never added, since one is made when its proposal is approved. A row of plans may give budget_amount, ctc_amount and gst_credit_amount as numbers. A row of lines changes the lot whose line_no (its Line No., see capex_capitalization_lines) it gives, or adds a lot where it gives none, and may give capitalization_date as year-month-day, capitalization_value and asset_block_value as numbers, asset_block by the code, path or name of one of your organisation's asset categories, and tnc_asset_type by the code or name of a value of its TNC Asset Type Master list. Nothing else is read. A key left out keeps what the plan or lot holds, and a key given empty clears it, except that an empty asset_block_value is the capitalization value, as it is for a lot added without one and for a lot whose two values were equal and whose capitalization value the row changes. A name a lot already holds keeps the value it holds, even one no longer offered. A carry forward's budget is its approved carryover and is refused where a row gives it as anything else. A TNC asset type a lot already had is taken off when its block is changed to one that is not Plant and Machinery. An optional row key, the row's place in the file, is given back with its outcome. Plans, lots and columns the file does not mention are left as they are, and nothing is deleted.

Each proposal the file changes is saved exactly as save_capex_capitalization_plan and save_capex_capitalization_line save it, with every check, permission and Form Studio setting that applies there, and all or nothing: a refused row leaves its whole proposal as it was, and the other proposals are still saved. A row that adds a lot exactly like one the plan already has, or one an earlier row of the file adds, is refused with DUPLICATE_LINE; a second identical lot is added on the screen. A proposal that would change nothing is counted in proposals_unchanged and not saved, whoever may change it. Nothing is written unless p_dry_run is false; a dry run, the default, saves each proposal and takes it back, so its answer is the upload's.

Returns ok, dry_run, written (whether anything was), proposals_updated, proposals_unchanged, proposals_refused, lines_added, lines_changed and outcomes: for each proposal updated (or that would be, in a dry run) its row, scheme_code, outcome UPDATED, columns (the plan's figures it changes), lines_added (the Line No. of each lot added), lines_changed (each lot changed, by line_no, with its columns) and needs (what the plan still needs before its capitalization can be approved, as capex_capitalization_plans.capitalization_needs says it, once changed); and for each row refused its row, scheme_code, outcome REFUSED, error_code, message and hint.



## OpenAPI

````yaml /api-reference/openapi.json post /rpc/import_capex_capitalization
openapi: 3.0.0
info:
  description: ''
  title: >-
    The only schema PostgREST exposes. Reads are security_invoker views; writes
    are SECURITY DEFINER functions. Rebuilt wholesale on every deploy — it holds
    no data.
  version: 12.2.3
servers:
  - url: https://app.assetinfinity.ai/api
security: []
tags:
  - name: Signing in
  - name: Profile
  - name: My work
  - name: Sites and locations
  - name: Assets
  - name: Asset lifecycle
  - name: Asset components
  - name: Kits
  - name: Work lifecycle
  - name: Work order execution
  - name: Work sequencing
  - name: Maintenance
  - name: Inspections
  - name: Checklists
  - name: Verification
  - name: Self verification
  - name: Inventory
  - name: Inventory detail
  - name: Parts demand
  - name: Procurement
  - name: Catalogue
  - name: Vendors and contracts
  - name: Contracts
  - name: Amendments
  - name: Vendor spend forecast
  - name: Workforce
  - name: Workforce detail
  - name: Capacity
  - name: Dispatch
  - name: Shutdown
  - name: Permits
  - name: Tools
  - name: Tools on jobs
  - name: Bookings
  - name: Booking hand over
  - name: Booking bills
  - name: Calibration history
  - name: Reliability
  - name: Sensors and meters
  - name: Readers
  - name: Trackers
  - name: Real-time location
  - name: Feeds
  - name: Energy
  - name: IT assets
  - name: IT asset software
  - name: IT asset topology
  - name: Warranty lookups
  - name: Map
  - name: Floor plans
  - name: Labels
  - name: Lost and found
  - name: Visitors
  - name: Root cause analysis
  - name: Costing
  - name: Finance
  - name: E-way bills
  - name: E-way bill filing
  - name: Budgets
  - name: Capex plans
  - name: Capex consolidation
  - name: Capex capitalization
  - name: FF&E plans
  - name: Documents
  - name: Document control
  - name: Document folders
  - name: Document tree
  - name: Knowledge
  - name: Reports
  - name: Dashboards
  - name: Extracts
  - name: Data exports
  - name: Audit center
  - name: Audit feed
  - name: Activity
  - name: Conversations
  - name: Notifications
  - name: Date reminders
  - name: Channels
  - name: Search
  - name: Copilot
  - name: Import
  - name: Bulk jobs
  - name: File exchange
  - name: Filing exceptions
  - name: Files
  - name: Sync
  - name: Support
  - name: API keys
  - name: Webhooks
  - name: MCP connections
  - name: MCP sign-in
  - name: SCIM provisioning
  - name: Directory sync
  - name: Security streams
  - name: Clarity
  - name: Single sign-on
  - name: Two-factor sign-in
  - name: Admin
  - name: Access
  - name: Lookups
  - name: Read models
  - name: Reference
  - name: Reference columns
  - name: Reference entry
  - name: List views
  - name: Mapping
  - name: Numbering
  - name: Branding
  - name: Custom fields
  - name: Form studio
  - name: Workflows
  - name: Workflow studio
  - name: Rules
  - name: Statuses and transitions
  - name: Currencies and locales
  - name: Today
  - name: Work configuration
  - name: Asset configuration
  - name: Inventory configuration
  - name: Tool configuration
  - name: Workforce configuration
  - name: Vendor and contract configuration
  - name: Document configuration
  - name: Inspection configuration
  - name: Sites, locations and the organisation
  - name: Setup
  - name: Features
  - name: Billing
  - name: Licence
  - name: Welcome
  - name: Tray
  - name: Tenant switch
  - name: Release
  - name: Upgrade
  - name: Telegram
  - name: Whatsapp
  - name: Inbound mail
  - name: Platform
externalDocs:
  description: PostgREST Documentation
  url: https://postgrest.org/en/v12/references/api.html
paths:
  /rpc/import_capex_capitalization:
    post:
      tags:
        - Capex capitalization
      summary: >-
        Change capex proposals' capitalization plans and their lots from a
        spreadsheet, a proposal at a time, or say what stops…
      description: >-
        Change capex proposals' capitalization plans and their lots from a
        spreadsheet, a proposal at a time, or say what stops each one.


        p_payload is {"plans": [...], "lines": [...]}, a row of the file each,
        at most 2,000 to a list. Every row names its proposal by scheme_code,
        the Request ID, among the capitalization plans you can see; a plan is
        never added, since one is made when its proposal is approved. A row of
        plans may give budget_amount, ctc_amount and gst_credit_amount as
        numbers. A row of lines changes the lot whose line_no (its Line No., see
        capex_capitalization_lines) it gives, or adds a lot where it gives none,
        and may give capitalization_date as year-month-day, capitalization_value
        and asset_block_value as numbers, asset_block by the code, path or name
        of one of your organisation's asset categories, and tnc_asset_type by
        the code or name of a value of its TNC Asset Type Master list. Nothing
        else is read. A key left out keeps what the plan or lot holds, and a key
        given empty clears it, except that an empty asset_block_value is the
        capitalization value, as it is for a lot added without one and for a lot
        whose two values were equal and whose capitalization value the row
        changes. A name a lot already holds keeps the value it holds, even one
        no longer offered. A carry forward's budget is its approved carryover
        and is refused where a row gives it as anything else. A TNC asset type a
        lot already had is taken off when its block is changed to one that is
        not Plant and Machinery. An optional row key, the row's place in the
        file, is given back with its outcome. Plans, lots and columns the file
        does not mention are left as they are, and nothing is deleted.


        Each proposal the file changes is saved exactly as
        save_capex_capitalization_plan and save_capex_capitalization_line save
        it, with every check, permission and Form Studio setting that applies
        there, and all or nothing: a refused row leaves its whole proposal as it
        was, and the other proposals are still saved. A row that adds a lot
        exactly like one the plan already has, or one an earlier row of the file
        adds, is refused with DUPLICATE_LINE; a second identical lot is added on
        the screen. A proposal that would change nothing is counted in
        proposals_unchanged and not saved, whoever may change it. Nothing is
        written unless p_dry_run is false; a dry run, the default, saves each
        proposal and takes it back, so its answer is the upload's.


        Returns ok, dry_run, written (whether anything was), proposals_updated,
        proposals_unchanged, proposals_refused, lines_added, lines_changed and
        outcomes: for each proposal updated (or that would be, in a dry run) its
        row, scheme_code, outcome UPDATED, columns (the plan's figures it
        changes), lines_added (the Line No. of each lot added), lines_changed
        (each lot changed, by line_no, with its columns) and needs (what the
        plan still needs before its capitalization can be approved, as
        capex_capitalization_plans.capitalization_needs says it, once changed);
        and for each row refused its row, scheme_code, outcome REFUSED,
        error_code, message and hint.
      parameters:
        - $ref: '#/components/parameters/preferParams'
      requestBody:
        content:
          application/json:
            schema:
              description: >-
                Change capex proposals' capitalization plans and their lots from
                a spreadsheet, a proposal at a time, or say what stops each one.


                p_payload is {"plans": [...], "lines": [...]}, a row of the file
                each, at most 2,000 to a list. Every row names its proposal by
                scheme_code, the Request ID, among the capitalization plans you
                can see; a plan is never added, since one is made when its
                proposal is approved. A row of plans may give budget_amount,
                ctc_amount and gst_credit_amount as numbers. A row of lines
                changes the lot whose line_no (its Line No., see
                capex_capitalization_lines) it gives, or adds a lot where it
                gives none, and may give capitalization_date as year-month-day,
                capitalization_value and asset_block_value as numbers,
                asset_block by the code, path or name of one of your
                organisation's asset categories, and tnc_asset_type by the code
                or name of a value of its TNC Asset Type Master list. Nothing
                else is read. A key left out keeps what the plan or lot holds,
                and a key given empty clears it, except that an empty
                asset_block_value is the capitalization value, as it is for a
                lot added without one and for a lot whose two values were equal
                and whose capitalization value the row changes. A name a lot
                already holds keeps the value it holds, even one no longer
                offered. A carry forward's budget is its approved carryover and
                is refused where a row gives it as anything else. A TNC asset
                type a lot already had is taken off when its block is changed to
                one that is not Plant and Machinery. An optional row key, the
                row's place in the file, is given back with its outcome. Plans,
                lots and columns the file does not mention are left as they are,
                and nothing is deleted.


                Each proposal the file changes is saved exactly as
                save_capex_capitalization_plan and
                save_capex_capitalization_line save it, with every check,
                permission and Form Studio setting that applies there, and all
                or nothing: a refused row leaves its whole proposal as it was,
                and the other proposals are still saved. A row that adds a lot
                exactly like one the plan already has, or one an earlier row of
                the file adds, is refused with DUPLICATE_LINE; a second
                identical lot is added on the screen. A proposal that would
                change nothing is counted in proposals_unchanged and not saved,
                whoever may change it. Nothing is written unless p_dry_run is
                false; a dry run, the default, saves each proposal and takes it
                back, so its answer is the upload's.


                Returns ok, dry_run, written (whether anything was),
                proposals_updated, proposals_unchanged, proposals_refused,
                lines_added, lines_changed and outcomes: for each proposal
                updated (or that would be, in a dry run) its row, scheme_code,
                outcome UPDATED, columns (the plan's figures it changes),
                lines_added (the Line No. of each lot added), lines_changed
                (each lot changed, by line_no, with its columns) and needs (what
                the plan still needs before its capitalization can be approved,
                as capex_capitalization_plans.capitalization_needs says it, once
                changed); and for each row refused its row, scheme_code, outcome
                REFUSED, error_code, message and hint.
              properties:
                p_dry_run:
                  format: boolean
                  type: boolean
                p_payload:
                  format: jsonb
              required:
                - p_payload
              type: object
          application/vnd.pgrst.object+json:
            schema:
              description: >-
                Change capex proposals' capitalization plans and their lots from
                a spreadsheet, a proposal at a time, or say what stops each one.


                p_payload is {"plans": [...], "lines": [...]}, a row of the file
                each, at most 2,000 to a list. Every row names its proposal by
                scheme_code, the Request ID, among the capitalization plans you
                can see; a plan is never added, since one is made when its
                proposal is approved. A row of plans may give budget_amount,
                ctc_amount and gst_credit_amount as numbers. A row of lines
                changes the lot whose line_no (its Line No., see
                capex_capitalization_lines) it gives, or adds a lot where it
                gives none, and may give capitalization_date as year-month-day,
                capitalization_value and asset_block_value as numbers,
                asset_block by the code, path or name of one of your
                organisation's asset categories, and tnc_asset_type by the code
                or name of a value of its TNC Asset Type Master list. Nothing
                else is read. A key left out keeps what the plan or lot holds,
                and a key given empty clears it, except that an empty
                asset_block_value is the capitalization value, as it is for a
                lot added without one and for a lot whose two values were equal
                and whose capitalization value the row changes. A name a lot
                already holds keeps the value it holds, even one no longer
                offered. A carry forward's budget is its approved carryover and
                is refused where a row gives it as anything else. A TNC asset
                type a lot already had is taken off when its block is changed to
                one that is not Plant and Machinery. An optional row key, the
                row's place in the file, is given back with its outcome. Plans,
                lots and columns the file does not mention are left as they are,
                and nothing is deleted.


                Each proposal the file changes is saved exactly as
                save_capex_capitalization_plan and
                save_capex_capitalization_line save it, with every check,
                permission and Form Studio setting that applies there, and all
                or nothing: a refused row leaves its whole proposal as it was,
                and the other proposals are still saved. A row that adds a lot
                exactly like one the plan already has, or one an earlier row of
                the file adds, is refused with DUPLICATE_LINE; a second
                identical lot is added on the screen. A proposal that would
                change nothing is counted in proposals_unchanged and not saved,
                whoever may change it. Nothing is written unless p_dry_run is
                false; a dry run, the default, saves each proposal and takes it
                back, so its answer is the upload's.


                Returns ok, dry_run, written (whether anything was),
                proposals_updated, proposals_unchanged, proposals_refused,
                lines_added, lines_changed and outcomes: for each proposal
                updated (or that would be, in a dry run) its row, scheme_code,
                outcome UPDATED, columns (the plan's figures it changes),
                lines_added (the Line No. of each lot added), lines_changed
                (each lot changed, by line_no, with its columns) and needs (what
                the plan still needs before its capitalization can be approved,
                as capex_capitalization_plans.capitalization_needs says it, once
                changed); and for each row refused its row, scheme_code, outcome
                REFUSED, error_code, message and hint.
              properties:
                p_dry_run:
                  format: boolean
                  type: boolean
                p_payload:
                  format: jsonb
              required:
                - p_payload
              type: object
          application/vnd.pgrst.object+json;nulls=stripped:
            schema:
              description: >-
                Change capex proposals' capitalization plans and their lots from
                a spreadsheet, a proposal at a time, or say what stops each one.


                p_payload is {"plans": [...], "lines": [...]}, a row of the file
                each, at most 2,000 to a list. Every row names its proposal by
                scheme_code, the Request ID, among the capitalization plans you
                can see; a plan is never added, since one is made when its
                proposal is approved. A row of plans may give budget_amount,
                ctc_amount and gst_credit_amount as numbers. A row of lines
                changes the lot whose line_no (its Line No., see
                capex_capitalization_lines) it gives, or adds a lot where it
                gives none, and may give capitalization_date as year-month-day,
                capitalization_value and asset_block_value as numbers,
                asset_block by the code, path or name of one of your
                organisation's asset categories, and tnc_asset_type by the code
                or name of a value of its TNC Asset Type Master list. Nothing
                else is read. A key left out keeps what the plan or lot holds,
                and a key given empty clears it, except that an empty
                asset_block_value is the capitalization value, as it is for a
                lot added without one and for a lot whose two values were equal
                and whose capitalization value the row changes. A name a lot
                already holds keeps the value it holds, even one no longer
                offered. A carry forward's budget is its approved carryover and
                is refused where a row gives it as anything else. A TNC asset
                type a lot already had is taken off when its block is changed to
                one that is not Plant and Machinery. An optional row key, the
                row's place in the file, is given back with its outcome. Plans,
                lots and columns the file does not mention are left as they are,
                and nothing is deleted.


                Each proposal the file changes is saved exactly as
                save_capex_capitalization_plan and
                save_capex_capitalization_line save it, with every check,
                permission and Form Studio setting that applies there, and all
                or nothing: a refused row leaves its whole proposal as it was,
                and the other proposals are still saved. A row that adds a lot
                exactly like one the plan already has, or one an earlier row of
                the file adds, is refused with DUPLICATE_LINE; a second
                identical lot is added on the screen. A proposal that would
                change nothing is counted in proposals_unchanged and not saved,
                whoever may change it. Nothing is written unless p_dry_run is
                false; a dry run, the default, saves each proposal and takes it
                back, so its answer is the upload's.


                Returns ok, dry_run, written (whether anything was),
                proposals_updated, proposals_unchanged, proposals_refused,
                lines_added, lines_changed and outcomes: for each proposal
                updated (or that would be, in a dry run) its row, scheme_code,
                outcome UPDATED, columns (the plan's figures it changes),
                lines_added (the Line No. of each lot added), lines_changed
                (each lot changed, by line_no, with its columns) and needs (what
                the plan still needs before its capitalization can be approved,
                as capex_capitalization_plans.capitalization_needs says it, once
                changed); and for each row refused its row, scheme_code, outcome
                REFUSED, error_code, message and hint.
              properties:
                p_dry_run:
                  format: boolean
                  type: boolean
                p_payload:
                  format: jsonb
              required:
                - p_payload
              type: object
          text/csv:
            schema:
              description: >-
                Change capex proposals' capitalization plans and their lots from
                a spreadsheet, a proposal at a time, or say what stops each one.


                p_payload is {"plans": [...], "lines": [...]}, a row of the file
                each, at most 2,000 to a list. Every row names its proposal by
                scheme_code, the Request ID, among the capitalization plans you
                can see; a plan is never added, since one is made when its
                proposal is approved. A row of plans may give budget_amount,
                ctc_amount and gst_credit_amount as numbers. A row of lines
                changes the lot whose line_no (its Line No., see
                capex_capitalization_lines) it gives, or adds a lot where it
                gives none, and may give capitalization_date as year-month-day,
                capitalization_value and asset_block_value as numbers,
                asset_block by the code, path or name of one of your
                organisation's asset categories, and tnc_asset_type by the code
                or name of a value of its TNC Asset Type Master list. Nothing
                else is read. A key left out keeps what the plan or lot holds,
                and a key given empty clears it, except that an empty
                asset_block_value is the capitalization value, as it is for a
                lot added without one and for a lot whose two values were equal
                and whose capitalization value the row changes. A name a lot
                already holds keeps the value it holds, even one no longer
                offered. A carry forward's budget is its approved carryover and
                is refused where a row gives it as anything else. A TNC asset
                type a lot already had is taken off when its block is changed to
                one that is not Plant and Machinery. An optional row key, the
                row's place in the file, is given back with its outcome. Plans,
                lots and columns the file does not mention are left as they are,
                and nothing is deleted.


                Each proposal the file changes is saved exactly as
                save_capex_capitalization_plan and
                save_capex_capitalization_line save it, with every check,
                permission and Form Studio setting that applies there, and all
                or nothing: a refused row leaves its whole proposal as it was,
                and the other proposals are still saved. A row that adds a lot
                exactly like one the plan already has, or one an earlier row of
                the file adds, is refused with DUPLICATE_LINE; a second
                identical lot is added on the screen. A proposal that would
                change nothing is counted in proposals_unchanged and not saved,
                whoever may change it. Nothing is written unless p_dry_run is
                false; a dry run, the default, saves each proposal and takes it
                back, so its answer is the upload's.


                Returns ok, dry_run, written (whether anything was),
                proposals_updated, proposals_unchanged, proposals_refused,
                lines_added, lines_changed and outcomes: for each proposal
                updated (or that would be, in a dry run) its row, scheme_code,
                outcome UPDATED, columns (the plan's figures it changes),
                lines_added (the Line No. of each lot added), lines_changed
                (each lot changed, by line_no, with its columns) and needs (what
                the plan still needs before its capitalization can be approved,
                as capex_capitalization_plans.capitalization_needs says it, once
                changed); and for each row refused its row, scheme_code, outcome
                REFUSED, error_code, message and hint.
              properties:
                p_dry_run:
                  format: boolean
                  type: boolean
                p_payload:
                  format: jsonb
              required:
                - p_payload
              type: object
        required: true
      responses:
        '200':
          description: OK
components:
  parameters:
    preferParams:
      description: Preference
      in: header
      name: Prefer
      required: false
      schema:
        enum:
          - params=single-object
        type: string

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.