Transaction Policies are rules that you configure to allow or disallow transactions based on specific attributes, like transaction limits, aggregation constraints, validity, time period, balance and many more.

{
  "openapi" : "3.0.1",
  "info":{
    "title":"",
    "version":""
  },

  "security" : [ {
    "zetaTokenBasedAuth" : [ ]
  } ],
  
   "tags":[
    {
      "name":"Transaction Categories"
    },
    {
      "name":"Transaction Policies"
    },
    
    {"name":"Transaction Policy Mappings"
    
    },  
    {
      "name":"Aggregate Expressions"
    },
    {
      "name":"Error Codes"
    },
  ],
  
  "paths" : {
    "/api/v1/ifi/{ifiId}/transactionPolicies/transactionCategories" : {
      "post" : {
        "tags" : [ "Transaction Categories" ],
        "summary" : "Create a new Transaction Category",
        "description" : "Create new transaction category",
        "operationId" : "createTransactionCategory",
        "parameters" : [ {
          "name" : "ifiId",
          "in" : "path",
          "description": "ID of the IFI (on-boarded organization) under which Transaction Category is created.",
          "required" : true,
          "schema" : {
            "type" : "integer",
            "format" : "int64"
          }
        } ],
        "requestBody" : {
          "content" : {
            "application/json" : {
              "schema" : {
                "$ref" : "#/components/schemas/TxnCategory"
              }
            }
          }
        },
        "responses" : {
          "default" : {
            "description" : "Transaction Category",
            "content" : {
              "application/json" : {
                "schema" : {
                  "$ref" : "#/components/schemas/TxnCategory"
                }
              }
            }
          }
        },
        "servers" : [ {
          "url" : "http://api.stage.zeta.in/athena-manager",
          "variables" : { }
        } ]
      },
      "get" : {
        "tags" : [ "Transaction Categories" ],
        "summary" : "Get Transaction Categories",
        "description" : "Returns transaction categories defined for an issuer",
        "operationId" : "getTransactionCategories",
        "parameters" : [ {
          "name" : "ifiId",
          "in" : "path",
          "description": "ID of the IFI (on-boarded organization) under which Transaction Categories defined for an issuer are retrieved.",
          "required" : true,
          "schema" : {
            "type" : "integer",
            "format" : "int64"
          }
        } ],
        "responses" : {
          "default" : {
            "description" : "Transaction Categories",
            "content" : {
              "application/json" : {
                "schema" : {
                  "$ref" : "#/components/schemas/GetTxnCategoriesResponse"
                }
              }
            }
          }
        },
        "servers" : [ {
          "url" : "http://api.stage.zeta.in/athena-manager",
          "variables" : { }
        } ]
      }
      
    },
    "/api/v1/ifi/{ifiId}/transactionPolicies/transactionCategories/{transactionCategoryCode}" : {
      "get" : {
        "tags" : [ "Transaction Categories" ],
        "summary" : "Get Transaction Category by Code",
        "description" : "Returns transaction category identified by transactionCategoryCode defined for an issuer",
        "operationId" : "getTransactionCategoryByCode",
        "parameters" : [ {
          "name" : "ifiId",
          "in" : "path",
          "description": "ID of the IFI (on-boarded organization) under which Transaction Category is retrieved by Code.",
          "required" : true,
          "schema" : {
            "type" : "integer",
            "format" : "int64"
          }
        }, {
          "name" : "transactionCategoryCode",
          "in" : "path",
          "required" : true,
          "schema" : {
            "type" : "string"
          }
        } ],
        "responses" : {
          "default" : {
            "description" : "Transaction Category",
            "content" : {
              "application/json" : {
                "schema" : {
                  "$ref" : "#/components/schemas/TxnCategory"
                }
              }
            }
          }
        },
        "servers" : [ {
          "url" : "http://api.stage.zeta.in/athena-manager",
          "variables" : { }
        } ]
      },
      "put" : {
        "tags" : [ "Transaction Categories" ],
        "summary" : "Update Transaction Category",
        "description" : "Update transaction category",
        "operationId" : "updateTransactionCategory",
        "parameters" : [ {
          "name" : "ifiId",
          "in" : "path",
          "required" : true,
          "schema" : {
            "type" : "integer",
            "format" : "int64"
          }
        }, {
          "name" : "transactionCategoryCode",
          "in" : "path",
          "description": "ID of the IFI (on-boarded organization) under which Transaction Categoru is updated.",
          "required" : true,
          "schema" : {
            "type" : "string"
          }
        } ],
        "requestBody" : {
          "content" : {
            "application/json" : {
              "schema" : {
                "$ref" : "#/components/schemas/UpdateTxnCategoryRequest"
              }
            }
          }
        },
        "responses" : {
          "default" : {
            "description" : "Transaction Category",
            "content" : {
              "application/json" : {
                "schema" : {
                  "$ref" : "#/components/schemas/TxnCategory"
                }
              }
            }
          }
        },
        "servers" : [ {
          "url" : "http://api.stage.zeta.in/athena-manager",
          "variables" : { }
        } ]
      }
    },
    
     "/api/v1/ifi/{ifiId}/accountHolders/{accountHolderID}/transactionCategory" : {
       "post" : {
          "tags" : [ "Transaction Categories" ],
          "summary" : "Create new Transaction Category for Account Holder",
          "description" : "Transactions on which policies are applied must be grouped before the actual policy is created and mapped. This is done by creating a transaction category and specifying the grouping criteria. </br> Use the endpoint to create a Transaction Category for an Account Holder. ",
          "operationId" : "createTransactionCategoryAH",
          "parameters" : [ 
            {
            "name" : "ifiId",
            "in" : "path",
            "description": "Unique identifier of the IFI.",
            "required" : true,
            "schema" : {
              "type" : "integer",
              "format" : "int64"
              }
            },
            {
              "name" : "accountHolderID",
              "in" : "path",
              "description": "Unique identifier of the Account Holder for whom transaction policy is created.",
              "required" : true,
              "schema" : {
                "type" : "integer",
                "format" : "int64"
                }
            }

          
          ],
          "requestBody" : {
            "content" : {
              "application/json" : {
                "schema" : {
                  "allOf":[
                  "$ref" : "#/components/schemas/createTxnCategoryRequest",
                  "example":{
                    "ifi": 140827,
                    "code": "POS_1112",
                    "description": "POS Group for 1112",
                    "transactionAttributes": [
                        {
                            "attrKey": "super-card.txn-type",
                            "attrVal": "POS",
                            "txnCategoryComparator": "EQUALS"
                        },
                        {
                            "attrKey": "super-card.card-id",
                            "attrVal": "1112",
                            "txnCategoryComparator": "CONTAINS"
                        }
                    ]
                }
                  ]
                }
              }
            }
          },
          "responses" : {
            "200" : {
              "description" : "Transaction Category created successfully",
              "content" : {
                "application/json" : {
                  "schema" : {
                    "allOf":[
                    "$ref" : "#/components/schemas/createTxnCategoryResponse",
                    "example":{
                      "ifi": 140827,
                      "code": "POS_1112",
                      "description": "POS Group for 1112",
                      "transactionAttributes": [
                          {
                              "id": 239,
                              "code": "POS_1112",
                              "attrKey": "super-card.txn-type",
                              "attrVal": "POS",
                              "txnCategoryComparator": "EQUALS"
                          },
                          {
                              "id": 240,
                              "code": "POS_1112",
                              "attrKey": "super-card.card-id",
                              "attrVal": "1112",
                              "txnCategoryComparator": "CONTAINS"
                          }
                      ]
                  }
                      
                    
                    ]
                  }
                }
              }
            }
          },
            "servers" : [ {
              "url" : "http://api.stage.zeta.in/athena-manager",
              "variables" : { }
            } ]
          },
        "get" : {
          "tags" : [ "Transaction Categories" ],
          "summary" : "Get all Transaction Categories for Account Holder",
          "description" : "Use the endpoint to get all the transaction categories created for a particular Account Holder.",
          "operationId" : "getTransactionCategoriesAH",
          "parameters" : [ {
            "name" : "ifiId",
            "in" : "path",
            "description": "Unique identifier of the IFI.",
            "required" : true,
            "schema" : {
              "type" : "integer",
              "format" : "int64"
            }
          
          },
          {
            "name" : "accountHolderID",
            "in" : "path",
            "description": "Unique identifier of the Account Holder for whom transaction categories are being fetched.",
            "required" : true,
            "schema" : {
              "type" : "integer",
              "format" : "int64"
              }
          } 
          
          
          
          ],
          "responses" : {
            "200" : {
              "description" : "Transaction Categories successfully retrieved",
              "content" : {
                "application/json" : {
                  "schema" : {
                    "$ref" : "#/components/schemas/GetTxnCategoriesResponse"
                  }
                }
              }
            }
          },
          "servers" : [ {
            "url" : "http://api.stage.zeta.in/athena-manager",
            "variables" : { }
          } ]
        }

    },
    
    
    
    
    "/api/v1/ifi/{ifiId}/transactionPolicies" : {
      "post" : {
        "tags" : [ "Transaction Policies" ],
        "summary" : "Create Transaction policy",
        "description" : "Returns created transaction policy",
        "operationId" : "createTransactionPolicy",
        "parameters" : [ {
          "name" : "ifiId",
          "in" : "path",
          "description": "ID of the IFI (on-boarded organization) under which Transaction Policy is created.",
          "required" : true,
          "schema" : {
            "type" : "integer",
            "format" : "int64"
          }
        } ],
        "requestBody" : {
          "content" : {
            "application/json" : {
              "schema" : {
                "$ref" : "#/components/schemas/CreateTransactionPolicyRequest"
              }
            }
          }
        },
        "responses" : {
          "default" : {
            "description" : "Transaction Policy",
            "content" : {
              "application/json" : {
                "schema" : {
                  "$ref" : "#/components/schemas/TransactionPolicyResponse"
                }
              }
            }
          }
        },
        "servers" : [ {
          "url" : "http://api.stage.zeta.in/athena-manager",
          "variables" : { }
        } ]
      },
      "get" : {
        "tags" : [ "Transaction Policies" ],
        "summary" : "Get Transaction policies",
        "description" : "Returns all transaction policies for an issuer",
        "operationId" : "getAllTransactionPolicyByIFI",
        "parameters" : [ 
            {
            "name" : "ifiId",
            "in" : "path",
            "description": "Unique identifier of the IFI.",
            "required" : true,
            "schema" : {
              "type" : "integer",
              "format" : "int64"
              }
            },
            {
              "name" : "accountHolderID",
              "in" : "path",
              "description": "Unique identifier of the Account Holder for whom transaction policy is created.",
              "required" : true,
              "schema" : {
                "type" : "integer",
                "format" : "int64"
                }
            }

          
          ],
        "responses" : {
          "default" : {
            "description" : "Transaction Policy",
            "content" : {
              "application/json" : {
                "schema" : {
                  "$ref" : "#/components/schemas/GetAllTransactionPoliciesResponse"
                }
              }
            }
          }
        },
        "servers" : [ {
          "url" : "http://api.stage.zeta.in/athena-manager",
          "variables" : { }
        } ]
      }
      
    },
    
  "/api/v1/ifi/{ifiId}/transactionPolicies/{policyID}/{state}":{
    "put" : {
        "tags" : [ "Transaction Policies" ],
        "summary" : "Update Transaction Policy state",
        "description" : "Use the endpoint to enable or disable the policy by changing its state.",
        "parameters" : [ 
          {
          "name" : "ifiId",
          "in" : "path",
          "description": "Unique identifier of the IFI.",
          "required" : true,
          "schema" : {
            "type" : "integer",
            "format" : "int64"
          },
        },
        {
          "name" : "policyID",
          "in" : "path",
          "description": "Unique identifier of the policy.",
          "required" : true,
          "schema" : {
            "type" : "string"
          },
        },
        {
          "name" : "state",
          "in" : "path",
          "description": "State of the policy. Allowed values: `enabled`, `disabled`",
          "required" : true,
          "schema" : {
            "type" : "string"
          },
        },
        
        
        
        ],
       
        "responses" : {
          "200" : {
            "description" : "Operation successful",
            "content" : {
              "application/json" : {
                "schema" : {
                 
                }
              }
            }
          }
        },
        "servers" : [ {
          "url" : "http://api.stage.zeta.in/athena-manager",
          "variables" : { }
        } ]
      }
    
    
  },
    
    
    
    
    "/api/v1/ifi/{ifiId}/accountHolders/{accountHolderID}/transactionPolicies" : {
      "post" : {
        "tags" : [ "Transaction Policies" ],
        "summary" : "Create Transaction policy for Account Holder",
        "description" : "Returns created transaction policy",
        "operationId" : "createTransactionPolicyAH",
        "parameters" : [ 
            {
            "name" : "ifiId",
            "in" : "path",
            "description": "Unique identifier of the IFI.",
            "required" : true,
            "schema" : {
              "type" : "integer",
              "format" : "int64"
              }
            },
            {
              "name" : "accountHolderID",
              "in" : "path",
              "description": "Unique identifier of the Account Holder for whom transaction policy is created.",
              "required" : true,
              "schema" : {
                "type" : "integer",
                "format" : "int64"
                }
            }

          
          ],
        "requestBody" : {
          "content" : {
            "application/json" : {
              "schema" : {
                "allOf":[
                "$ref" : "#/components/schemas/CreateTransactionPolicyRequest",
                "example":{
                  "ifiId": 140827,
                  "code": "eCOM Transactions",
                  "description": "Enable eCOM Transaction with limit",
                  "policyViolationAction": "DECLINE_AND_NOTIFY",
                  "txnConstraints": [
                      {
                          "action": "DEBIT",
                          "allowedTxnCategoryCodes": [
                              "ECOM_1112"
                          ],
                          "disallowedTxnCategoryCodes": [],
                          "allowedTimeslices": [
                              "*7-23 * * *"
                          ],
                          "disallowedTimeslices": [
              ],
                          "errorCode": "GENERIC_ERROR"
                      }
                  ],
                  "txnLimits": [
                      {
                          "action": "DEBIT",
                          "categoryCode": "ECOM_1112",
                          "errorCode": "GENERIC_ERROR",
                          "maxAllowedAmount": 1000000,
                          "minRequiredAmount": 0
                      }
                  ]
              }
                ]
              }
            }
          }
        },
        "responses" : {
          "default" : {
            "description" : "Transaction Policy",
            "content" : {
              "application/json" : {
                "schema" : {
                  "allOf":[
                  "$ref" : "#/components/schemas/TransactionPolicyResponse",
                  "example":{
                    "id": "05a12e14-2d94-4a2a-bee2-493f4230622c",
                    "ifiId": 140827,
                    "code": "eCOM Transactions",
                    "status": "ENABLED",
                    "description": "Enable eCOM Transaction with limit",
                    "attributes": {},
                    "validFrom": 1584209741088,
                    "validUntil": 1741976141088,
                    "policyViolationAction": "DECLINE_AND_NOTIFY",
                    "txnConstraints": [
                        {
                            "id": 273,
                            "policyVersionID": 5167207390205832172,
                            "action": "DEBIT",
                            "allowedTxnCategoryCodes": [
                                "ECOM_1112"
                            ],
                            "disallowedTxnCategoryCodes": [],
                            "allowedTimeSlices": [],
                            "disallowedTimeSlices": [],
                            "errorCode": "GENERIC_ERROR"
                        }
                    ],
                    "txnLimits": [
                        {
                            "id": 4844,
                            "policyVersionID": 5167207390205832172,
                            "action": "DEBIT",
                            "categoryCode": "ECOM_1112",
                            "minRequiredAmount": 0,
                            "maxAllowedAmount": 1000000,
                            "errorCode": "GENERIC_ERROR"
                        }
                    ],
                    "balanceLimits": [],
                    "volumeLimits": [],
                    "velocityLimits": [],
                    "createdAt": 1584209741156,
                    "updatedAt": 1584209741156,
                    "headers": {}
                }
                  ]
                }
              }
            }
          }
        },
        "servers" : [ {
          "url" : "http://api.stage.zeta.in/athena-manager",
          "variables" : { }
        } ]
      },
      "get" : {
        "tags" : [ "Transaction Policies" ],
        "summary" : "Get all Transaction policies for Account Holder",
        "description" : "Use the endpoint to get all the transaction policies created for an Account Holder",
        "operationId" : "getAllTransactionPolicyAH",
        "parameters" : [ 
            {
            "name" : "ifiId",
            "in" : "path",
            "description": "Unique identifier of the IFI.",
            "required" : true,
            "schema" : {
              "type" : "integer",
              "format" : "int64"
              }
            },
            {
              "name" : "accountHolderID",
              "in" : "path",
              "description": "Unique identifier of the Account Holder for whom transaction policy is created.",
              "required" : true,
              "schema" : {
                "type" : "integer",
                "format" : "int64"
                }
            }

          
          ],
        "responses" : {
          "200" : {
            "description" : "Operation Successful",
            "content" : {
              "application/json" : {
                "schema" : {
                  "allOf":[
                  "$ref" : "#/components/schemas/GetAllTransactionPoliciesResponse",
                  "example":{
                    "id": "05a12e14-2d94-4a2a-bee2-493f4230622c",
                    "ifiId": 140827,
                    "code": "eCOM Transactions",
                    "status": "ENABLED",
                    "description": "Enable eCOM Transaction with limit",
                    "attributes": {},
                    "validFrom": 1584209741088,
                    "validUntil": 1741976141088,
                    "policyViolationAction": "DECLINE_AND_NOTIFY",
                    "txnConstraints": [
                        {
                            "id": 274,
                            "policyVersionID": 4848132788987861828,
                            "action": "DEBIT",
                            "allowedTxnCategoryCodes": [
                                "ECOM_1112"
                            ],
                            "disallowedTxnCategoryCodes": [],
                            "allowedTimeSlices": [],
                            "disallowedTimeSlices": [],
                            "errorCode": "GENERIC_ERROR"
                        }
                    ],
                    "txnLimits": [
                        {
                            "id": 4845,
                            "policyVersionID": 4848132788987861828,
                            "action": "DEBIT",
                            "categoryCode": "ECOM_1112",
                            "minRequiredAmount": 0,
                            "maxAllowedAmount": 2000000,
                            "errorCode": "GENERIC_ERROR"
                        }
                    ],
                    "balanceLimits": [],
                    "volumeLimits": [],
                    "velocityLimits": [],
                    "createdAt": 1584209741156,
                    "updatedAt": 1584209741156,
                    "headers": {}
                }
                  ]
                }
              }
            }
          }
        },
        "servers" : [ {
          "url" : "http://api.stage.zeta.in/athena-manager",
          "variables" : { }
        } ]
      }
      
    },
    
    
    
    "/api/v1/ifi/{ifiId}/transactionPolicies/codes/{code}" : {
      "get" : {
        "tags" : [ "Transaction Policies" ],
        "summary" : "Get transaction policy by code",
        "description" : "Returns transaction policy searched by code",
        "operationId" : "getTransactionPolicyByCode",
        "parameters" : [ {
          "name" : "ifiId",
          "in" : "path",
          "description": "ID of the IFI (on-boarded organization) under which Transaction Policy is retrieved by code.",
          "required" : true,
          "schema" : {
            "type" : "integer",
            "format" : "int64"
          }
        }, {
          "name" : "code",
          "in" : "path",
          "required" : true,
          "schema" : {
            "type" : "string"
          }
        } ],
        "responses" : {
          "default" : {
            "description" : "Transaction Policy",
            "content" : {
              "application/json" : {
                "schema" : {
                  "$ref" : "#/components/schemas/TransactionPolicyResponse"
                }
              }
            }
          }
        },
        "servers" : [ {
          "url" : "http://api.stage.zeta.in/athena-manager",
          "variables" : { }
        } ]
      }
    },
    "/api/v1/ifi/{ifiId}/transactionPolicies/{transactionPolicyId}" : {
      "get" : {
        "tags" : [ "Transaction Policies" ],
        "summary" : "Get Transaction policy by ID",
        "description" : "Returns transaction policy searched with ID",
        "operationId" : "getTransactionPolicyByID",
        "parameters" : [ {
          "name" : "ifiId",
          "in" : "path",
          "description": "ID of the IFI (on-boarded oragnization) under which the Transaction Policy is retrieved by ID.",
          "required" : true,
          "schema" : {
            "type" : "integer",
            "format" : "int64"
          }
        }, {
          "name" : "transactionPolicyId",
          "in" : "path",
          "description": "ID of the Transaction Policy that is retrieved.", 
          "required" : true,
          "schema" : {
            "type" : "string"
          }
        } ],
        "responses" : {
          "default" : {
            "description" : "Transaction Policy",
            "content" : {
              "application/json" : {
                "schema" : {
                  "$ref" : "#/components/schemas/TransactionPolicyResponse"
                }
              }
            }
          }
        },
        "servers" : [ {
          "url" : "http://api.stage.zeta.in/athena-manager",
          "variables" : { }
        } ]
      },
      "put" : {
        "tags" : [ "Transaction Policies" ],
        "summary" : "Update Transaction policy",
        "description" : "Updates transaction policy identified by ID",
        "operationId" : "updateTransactionPolicy",
        "parameters" : [ {
          "name" : "ifiId",
          "in" : "path",
          "required" : true,
          "description": "ID of the IFI (on-boarded organization) under which Transaction Policy is updated by ID.",
          "schema" : {
            "type" : "integer",
            "format" : "int64"
          }
        }, {
          "name" : "transactionPolicyId",
          "in" : "path",  
          "description": "ID of the Transaction Policy that is updated.",
          "required" : true,
          "schema" : {
            "type" : "string"
          }
        } ],
        "requestBody" : {
          "content" : {
            "application/json" : {
              "schema" : {
                "$ref" : "#/components/schemas/UpdateTransactionPolicyRequest"
              }
            }
          }
        },
        "responses" : {
          "default" : {
            "description" : "Updated Transaction Policy",
            "content" : {
              "application/json" : {
                "schema" : {
                  "$ref" : "#/components/schemas/TransactionPolicyResponse"
                }
              }
            }
          }
        },
        "servers" : [ {
          "url" : "http://api.stage.zeta.in/athena-manager",
          "variables" : { }
        } ]
      }
    },
    
    
    "/api/v1/ifi/{ifiId}/accountHolders/{accountHolderID}/policyMappings" : {
      "post" : {
        "tags" : [ "Transaction Policy Mappings" ],
        "summary" : "Map Transaction Policy to Account Holder",
        "description" : "Use the endpoint to map a Transaction Policy to an Account Holder. You need to specify the policy's ID in the request body.",
        "parameters" : [ 
            {
            "name" : "ifiId",
            "in" : "path",
            "description": "Unique identifier of the IFI.",
            "required" : true,
            "schema" : {
              "type" : "integer",
              "format" : "int64"
              }
            },
            {
              "name" : "accountHolderID",
              "in" : "path",
              "description": "Unique identifier of the Account Holder to whom transaction policy is mapped.",
              "required" : true,
              "schema" : {
                "type" : "integer",
                "format" : "int64"
                }
            }

          
          ],
        "requestBody" : {
          "content" : {
            "application/json" : {
              "schema" : {
                "allOf":[
                "$ref" : "#/components/schemas/MapTransactionPolicyRequestAH",
                "example":{
                  "policyID": "05a12e14-2d94-4a2a-bee2-493f4230622c"
                }
                ]
              }
            }
          }
        },
        "responses" : {
          "default" : {
            "description" : "Transaction Policy",
            "content" : {
              "application/json" : {
                "schema" : {
                  "allOf":[
                  "$ref" : "#/components/schemas/TransactionPolicyResponse",
                  "example":{
                    "id": "05a12e14-2d94-4a2a-bee2-493f4230622c",
                    "ifiId": 140827,
                    "code": "eCOM Transactions",
                    "status": "ENABLED",
                    "description": "Enable eCOM Transaction with limit",
                    "attributes": {},
                    "validFrom": 1584209741088,
                    "validUntil": 1741976141088,
                    "policyViolationAction": "DECLINE_AND_NOTIFY",
                    "txnConstraints": [
                        {
                            "id": 273,
                            "policyVersionID": 5167207390205832172,
                            "action": "DEBIT",
                            "allowedTxnCategoryCodes": [
                                "ECOM_1112"
                            ],
                            "disallowedTxnCategoryCodes": [],
                            "allowedTimeSlices": [],
                            "disallowedTimeSlices": [],
                            "errorCode": "GENERIC_ERROR"
                        }
                    ],
                    "txnLimits": [
                        {
                            "id": 4844,
                            "policyVersionID": 5167207390205832172,
                            "action": "DEBIT",
                            "categoryCode": "ECOM_1112",
                            "minRequiredAmount": 0,
                            "maxAllowedAmount": 1000000,
                            "errorCode": "GENERIC_ERROR"
                        }
                    ],
                    "balanceLimits": [],
                    "volumeLimits": [],
                    "velocityLimits": [],
                    "createdAt": 1584209741156,
                    "updatedAt": 1584209741156,
                    "headers": {}
                }
                  ]
                }
              }
            }
          }
        },
        "servers" : [ {
          "url" : "http://api.stage.zeta.in/athena-manager",
          "variables" : { }
        } ]
      },
      "get" : {
        "tags" : [ "Transaction Policy Mappings" ],
        "summary" : "Get all Transaction Policies mapped for Account Holder",
        "description" : "Use the endpoint to get all the transaction policies mapped for an Account Holder.",
        "parameters" : [ 
            {
            "name" : "ifiId",
            "in" : "path",
            "description": "Unique identifier of the IFI.",
            "required" : true,
            "schema" : {
              "type" : "integer",
              "format" : "int64"
              }
            },
            {
              "name" : "accountHolderID",
              "in" : "path",
              "description": "Unique identifier of the Account Holder for whom transaction policy is created.",
              "required" : true,
              "schema" : {
                "type" : "integer",
                "format" : "int64"
                }
            }

          
          ],
        "responses" : {
          "200" : {
            "description" : "Operation successful",
            "content" : {
              "application/json" : {
                "schema" : {
                  "allOf":[
                  "$ref" : "#/components/schemas/GetAllTransactionPoliciesResponse",
                  "example":{
                    "id": "05a12e14-2d94-4a2a-bee2-493f4230622c",
                    "ifiId": 140827,
                    "code": "eCOM Transactions",
                    "status": "ENABLED",
                    "description": "Enable eCOM Transaction with limit",
                    "attributes": {},
                    "validFrom": 1584209741088,
                    "validUntil": 1741976141088,
                    "policyViolationAction": "DECLINE_AND_NOTIFY",
                    "txnConstraints": [
                        {
                            "id": 274,
                            "policyVersionID": 4848132788987861828,
                            "action": "DEBIT",
                            "allowedTxnCategoryCodes": [
                                "ECOM_1112"
                            ],
                            "disallowedTxnCategoryCodes": [],
                            "allowedTimeSlices": [],
                            "disallowedTimeSlices": [],
                            "errorCode": "GENERIC_ERROR"
                        }
                    ],
                    "txnLimits": [
                        {
                            "id": 4845,
                            "policyVersionID": 4848132788987861828,
                            "action": "DEBIT",
                            "categoryCode": "ECOM_1112",
                            "minRequiredAmount": 0,
                            "maxAllowedAmount": 2000000,
                            "errorCode": "GENERIC_ERROR"
                        }
                    ],
                    "balanceLimits": [],
                    "volumeLimits": [],
                    "velocityLimits": [],
                    "createdAt": 1584209741156,
                    "updatedAt": 1584209741156,
                    "headers": {}
                }
                  ]
                }
              }
            }
          }
        },
        "servers" : [ {
          "url" : "http://api.stage.zeta.in/athena-manager",
          "variables" : { }
        } ]
      }
      
    },
    
    
    
    
    "/api/v1/ifi/{ifiId}/transactionPolicies/aggregateExpressions" : {
      "post" : {
        "tags" : [ "Aggregate Expressions" ],
        "summary" : "Create a new Aggregate Expression",
        "description" : "Create new Aggregate Expression",
        "operationId" : "createAggregateExpression",
        "parameters" : [ {
          "name" : "ifiId",
          "in" : "path",
          "description": "ID of the IFI (on-boarded organization) under which new Aggregate Expression is created.",
          "required" : true,
          "schema" : {
            "type" : "integer",
            "format" : "int64"
          }
        } ],
        "requestBody" : {
          "content" : {
            "application/json" : {
              "schema" : {
                "$ref" : "#/components/schemas/AggregateExpression"
              }
            }
          }
        },
        "responses" : {
          "default" : {
            "description" : "Aggregate Expression",
            "content" : {
              "application/json" : {
                "schema" : {
                  "$ref" : "#/components/schemas/AggregateExpression"
                }
              }
            }
          }
        },
        "servers" : [ {
          "url" : "http://api.stage.zeta.in/athena-manager",
          "variables" : { }
        } ]
      },
      "get" : {
        "tags" : [ "Aggregate Expressions" ],
        "summary" : "Get Aggregate Expressions",
        "description" : "Returns aggregate expressions defined for an issuer",
        "operationId" : "getAggregateExpressions",
        "parameters" : [ {
          "name" : "ifiId",
          "in" : "path",
          "description": "ID of the IFI (on-boarded organization) under which aggregate expressions are retrieved.",
          "required" : true,
          "schema" : {
            "type" : "integer",
            "format" : "int64"
          }
        } ],
        "responses" : {
          "default" : {
            "description" : "Aggregate Expressions",
            "content" : {
              "application/json" : {
                "schema" : {
                  "$ref" : "#/components/schemas/GetAggregateExpressionsResponse"
                }
              }
            }
          }
        },
        "servers" : [ {
          "url" : "http://api.stage.zeta.in/athena-manager",
          "variables" : { }
        } ]
      }
      
    },
    "/api/v1/ifi/{ifiId}/transactionPolicies/aggregateExpressions/{aggregateExpressionCode}" : {
      "get" : {
        "tags" : [ "Aggregate Expressions" ],
        "summary" : "Get Aggregate Expression by code",
        "description" : "Returns aggregate expression identified by the aggregateExpressionCode",
        "operationId" : "getAggregateExpressionByCode",
        "parameters" : [ {
          "name" : "ifiId",
          "description": "ID of the IFI (on-boarded organization) under which Transaction Expression is retrieved by aggregateExpressionCode.",
          "in" : "path",
          "required" : true,
          "schema" : {
            "type" : "integer",
            "format" : "int64"
          }
        },{
          "name" : "aggregateExpressionCode",
          "in" : "path",
          "description": "ID of the aggregate expression based on which the aggregate expression is retrieved.",
          "required" : true,
          "schema" : {
            "type" : "string"
          }
        } ],
        "responses" : {
          "default" : {
            "description" : "Aggregate Expression by Code",
            "content" : {
              "application/json" : {
                "schema" : {
                  "$ref" : "#/components/schemas/AggregateExpression"
                }
              }
            }
          }
        },
        "servers" : [ {
          "url" : "http://api.stage.zeta.in/athena-manager",
          "variables" : { }
        } ]
      },
      "put" : {
        "tags" : [ "Aggregate Expressions" ],
        "summary" : "Update Aggregate Expression",
        "description" : "Updates Aggregate Expression identified by aggregateExpressionCode",
        "operationId" : "updateAggregateExpression",
        "parameters" : [ {
          "name" : "ifiId",
          "in" : "path",
          "description": "ID of the IFI (on-boarded organization) under Aggregate Expression is updated based on aggregateExpressionCode.",
          "required" : true,
          "schema" : {
            "type" : "integer",
            "format" : "int64"
          }
        }, {
          "name" : "aggregateExpressionCode",
          "in" : "path",
          "description": "ID of the Aggregate Expression.",
          "required" : true,
          "schema" : {
            "type" : "string"
          }
        } ],
        "requestBody" : {
          "content" : {
            "application/json" : {
              "schema" : {
                "$ref" : "#/components/schemas/UpdateAggregateExpressionRequest"
              }
            }
          }
        },
        "responses" : {
          "default" : {
            "description" : "Updated Aggregate Expression",
            "content" : {
              "application/json" : {
                "schema" : {
                  "$ref" : "#/components/schemas/AggregateExpression"
                }
              }
            }
          }
        },
        "servers" : [ {
          "url" : "http://api.stage.zeta.in/athena-manager",
          "variables" : { }
        } ]
      }
    },
    "/api/v1/ifi/{ifiId}/transactionPolicies/errorCodes" : {
      "post" : {
        "tags" : [ "Error Codes" ],
        "summary" : "Create a new ErrorCode",
        "description" : "Create new error code",
        "operationId" : "createErrorCode",
        "parameters" : [ {
          "name" : "ifiId",
          "in" : "path",
          "description": "ID of the IFI (on-boarded organization) under which a new error code is created for a Transaction Policy.",
          "required" : true,
          "schema" : {
            "type" : "integer",
            "format" : "int64"
          }
        } ],
        "requestBody" : {
          "content" : {
            "application/json" : {
              "schema" : {
                "$ref" : "#/components/schemas/ErrorCode"
              }
            }
          }
        },
        "responses" : {
          "default" : {
            "description" : "Aggregate Expression",
            "content" : {
              "application/json" : {
                "schema" : {
                  "$ref" : "#/components/schemas/ErrorCode"
                }
              }
            }
          }
        },
        "servers" : [ {
          "url" : "http://api.stage.zeta.in/athena-manager",
          "variables" : { }
        } ]
      },
      "get" : {
        "tags" : [ "Error Codes" ],
        "summary" : "Get Transaction policy error codes",
        "description" : "Returns transaction policy error codes for an issuer",
        "operationId" : "getTransactionPolicyErrorCodeList",
        "parameters" : [ {
          "name" : "ifiId",
          "in" : "path",
          "description": "ID of the IFI (on-boarded organization) under which Transaction Policy error codes are returned.",
          "required" : true,
          "schema" : {
            "type" : "integer",
            "format" : "int64"
          }
        } ],
        "responses" : {
          "default" : {
            "description" : "Transaction Policy",
            "content" : {
              "application/json" : {
                "schema" : {
                  "$ref" : "#/components/schemas/GetTransactionPolicyErrorCodeListResponse"
                }
              }
            }
          }
        },
        "servers" : [ {
          "url" : "http://api.stage.zeta.in/athena-manager",
          "variables" : { }
        } ]
      }
    }
  },
  "components" : {
    "schemas" : {
      "JsonArray" : {
        "type" : "object",
        "properties" : {
          "asBoolean" : {
            "type" : "boolean"
          },
          "asInt" : {
            "type" : "integer",
            "format" : "int32"
          },
          "asNumber" : {
            "type" : "number"
          },
          "asDouble" : {
            "type" : "number",
            "format" : "double"
          },
          "asFloat" : {
            "type" : "number",
            "format" : "float"
          },
          "asLong" : {
            "type" : "integer",
            "format" : "int64"
          },
          "asByte" : {
            "type" : "string",
            "format" : "byte"
          },
          "asCharacter" : {
            "type" : "string"
          },
          "asBigDecimal" : {
            "type" : "number"
          },
          "asBigInteger" : {
            "type" : "integer"
          },
          "asShort" : {
            "type" : "integer",
            "format" : "int32"
          },
          "asString" : {
            "type" : "string"
          },
          "jsonNull" : {
            "type" : "boolean"
          },
          "jsonObject" : {
            "type" : "boolean"
          },
          "asJsonObject" : {
            "$ref" : "#/components/schemas/JsonObject"
          },
          "jsonArray" : {
            "type" : "boolean"
          },
          "jsonPrimitive" : {
            "type" : "boolean"
          },
          "asJsonArray" : {
            "$ref" : "#/components/schemas/JsonArray"
          },
          "asJsonPrimitive" : {
            "$ref" : "#/components/schemas/JsonPrimitive"
          },
          "asJsonNull" : {
            "$ref" : "#/components/schemas/JsonNull"
          }
        }
      },
      "JsonElement" : {
        "type" : "object",
        "properties" : {
          "jsonNull" : {
            "type" : "boolean"
          },
          "jsonObject" : {
            "type" : "boolean"
          },
          "asJsonObject" : {
            "$ref" : "#/components/schemas/JsonObject"
          },
          "asBoolean" : {
            "type" : "boolean"
          },
          "asInt" : {
            "type" : "integer",
            "format" : "int32"
          },
          "jsonArray" : {
            "type" : "boolean"
          },
          "jsonPrimitive" : {
            "type" : "boolean"
          },
          "asJsonArray" : {
            "$ref" : "#/components/schemas/JsonArray"
          },
          "asJsonPrimitive" : {
            "$ref" : "#/components/schemas/JsonPrimitive"
          },
          "asJsonNull" : {
            "$ref" : "#/components/schemas/JsonNull"
          },
          "asNumber" : {
            "type" : "number"
          },
          "asDouble" : {
            "type" : "number",
            "format" : "double"
          },
          "asFloat" : {
            "type" : "number",
            "format" : "float"
          },
          "asLong" : {
            "type" : "integer",
            "format" : "int64"
          },
          "asByte" : {
            "type" : "string",
            "format" : "byte"
          },
          "asCharacter" : {
            "type" : "string"
          },
          "asBigDecimal" : {
            "type" : "number"
          },
          "asBigInteger" : {
            "type" : "integer"
          },
          "asShort" : {
            "type" : "integer",
            "format" : "int32"
          },
          "asString" : {
            "type" : "string"
          }
        }
      },
      "JsonNull" : {
        "type" : "object",
        "properties" : {
          "jsonNull" : {
            "type" : "boolean"
          },
          "jsonObject" : {
            "type" : "boolean"
          },
          "asJsonObject" : {
            "$ref" : "#/components/schemas/JsonObject"
          },
          "asBoolean" : {
            "type" : "boolean"
          },
          "asInt" : {
            "type" : "integer",
            "format" : "int32"
          },
          "jsonArray" : {
            "type" : "boolean"
          },
          "jsonPrimitive" : {
            "type" : "boolean"
          },
          "asJsonArray" : {
            "$ref" : "#/components/schemas/JsonArray"
          },
          "asJsonPrimitive" : {
            "$ref" : "#/components/schemas/JsonPrimitive"
          },
          "asJsonNull" : {
            "$ref" : "#/components/schemas/JsonNull"
          },
          "asNumber" : {
            "type" : "number"
          },
          "asDouble" : {
            "type" : "number",
            "format" : "double"
          },
          "asFloat" : {
            "type" : "number",
            "format" : "float"
          },
          "asLong" : {
            "type" : "integer",
            "format" : "int64"
          },
          "asByte" : {
            "type" : "string",
            "format" : "byte"
          },
          "asCharacter" : {
            "type" : "string"
          },
          "asBigDecimal" : {
            "type" : "number"
          },
          "asBigInteger" : {
            "type" : "integer"
          },
          "asShort" : {
            "type" : "integer",
            "format" : "int32"
          },
          "asString" : {
            "type" : "string"
          }
        }
      },
      "JsonObject" : {
        "type" : "object",
        "properties" : {
          "jsonNull" : {
            "type" : "boolean"
          },
          "jsonObject" : {
            "type" : "boolean"
          },
          "asJsonObject" : {
            "$ref" : "#/components/schemas/JsonObject"
          },
          "asBoolean" : {
            "type" : "boolean"
          },
          "asInt" : {
            "type" : "integer",
            "format" : "int32"
          },
          "jsonArray" : {
            "type" : "boolean"
          },
          "jsonPrimitive" : {
            "type" : "boolean"
          },
          "asJsonArray" : {
            "$ref" : "#/components/schemas/JsonArray"
          },
          "asJsonPrimitive" : {
            "$ref" : "#/components/schemas/JsonPrimitive"
          },
          "asJsonNull" : {
            "$ref" : "#/components/schemas/JsonNull"
          },
          "asNumber" : {
            "type" : "number"
          },
          "asDouble" : {
            "type" : "number",
            "format" : "double"
          },
          "asFloat" : {
            "type" : "number",
            "format" : "float"
          },
          "asLong" : {
            "type" : "integer",
            "format" : "int64"
          },
          "asByte" : {
            "type" : "string",
            "format" : "byte"
          },
          "asCharacter" : {
            "type" : "string"
          },
          "asBigDecimal" : {
            "type" : "number"
          },
          "asBigInteger" : {
            "type" : "integer"
          },
          "asShort" : {
            "type" : "integer",
            "format" : "int32"
          },
          "asString" : {
            "type" : "string"
          }
        }
      },
      "JsonPrimitive" : {
        "type" : "object",
        "properties" : {
          "value" : {
            "type" : "object",
            "writeOnly" : true
          },
          "number" : {
            "type" : "boolean"
          },
          "boolean" : {
            "type" : "boolean"
          },
          "asBoolean" : {
            "type" : "boolean"
          },
          "string" : {
            "type" : "boolean"
          },
          "asInt" : {
            "type" : "integer",
            "format" : "int32"
          },
          "asNumber" : {
            "type" : "number"
          },
          "asDouble" : {
            "type" : "number",
            "format" : "double"
          },
          "asFloat" : {
            "type" : "number",
            "format" : "float"
          },
          "asLong" : {
            "type" : "integer",
            "format" : "int64"
          },
          "asByte" : {
            "type" : "string",
            "format" : "byte"
          },
          "asCharacter" : {
            "type" : "string"
          },
          "asBigDecimal" : {
            "type" : "number"
          },
          "asBigInteger" : {
            "type" : "integer"
          },
          "asShort" : {
            "type" : "integer",
            "format" : "int32"
          },
          "asString" : {
            "type" : "string"
          },
          "jsonNull" : {
            "type" : "boolean"
          },
          "jsonObject" : {
            "type" : "boolean"
          },
          "asJsonObject" : {
            "$ref" : "#/components/schemas/JsonObject"
          },
          "jsonArray" : {
            "type" : "boolean"
          },
          "jsonPrimitive" : {
            "type" : "boolean"
          },
          "asJsonArray" : {
            "$ref" : "#/components/schemas/JsonArray"
          },
          "asJsonPrimitive" : {
            "$ref" : "#/components/schemas/JsonPrimitive"
          },
          "asJsonNull" : {
            "$ref" : "#/components/schemas/JsonNull"
          }
        }
      },
      "createTxnCategoryRequest" : {
        "type" : "object",
        "properties" : {
          "ifi" : {
            "type" : "integer",
            "format" : "int64",
            "description":"Unique identifier of the IFI."
          },
          "code" : {
            "type" : "string",
            "description":"Unique identifier of the transaction category."
          },
          "description" : {
            "type" : "string",
            "description":"Human readable description for the transaction category."
          },
          "transactionAttributes" : {
            "type" : "array",
            "items" : {
              "type":"object",
              "properties":{
                "attrKey" : {
                  "type" : "string",
                  "description":"System generated key that defines the grouping criteria. Used in conjunction with `attrVal` parameter."
          },
                "attrVal" : {
                   "type" : "string",
                    "description":"Value according to the key mentioned in attrKey."
          },
                "txnCategoryComparator" : {
                  "type" : "string",
                  "enum" : [ "EQUALS", "CONTAINS" ],
                  "description":"Transaction Category comparator."
          }
                
              }
            }
          }
        }
      },
      "createTxnCategoryResponse" : {
        "type" : "object",
        "properties" : {
          "ifi" : {
            "type" : "integer",
            "format" : "int64",
            "description":"Unique identifier of the IFI."
          },
          "code" : {
            "type" : "string",
            "description":"Unique identifier of the transaction category."
          },
          "description" : {
            "type" : "string",
            "description":"Human readable description for the transaction category."
          },
          "transactionAttributes" : {
            "type" : "array",
            "items" : {
              "type":"object",
              "properties":{
                "id" : {
                "type" : "integer",
                "description":"Unique identifier assigned to the transcation attribute"
                },
                "code" : {
                "type" : "string",
                "description":"Unique identifier of the transaction category."
                },
                "attrKey" : {
                  "type" : "string",
                  "description":"System generated key that defines the grouping criteria. Used in conjunction with `attrVal` parameter."
                },
                "attrVal" : {
                   "type" : "string",
                    "description":"Value according to the key mentioned in attrKey."
               },
                "txnCategoryComparator" : {
                  "type" : "string",
                  "enum" : [ "EQUALS", "CONTAINS" ],
                  "description":"Transaction Category comparator."
                }
                
              }
            }
          }
        }
      },
      
      "GetAllTransactionPoliciesResponse" : {
        "type" : "object",
        "properties" : {
          "policies" : {
            "type" : "array",
            "items" : {
              "$ref" : "#/components/schemas/PolicyEntry"
            }
          }
        }
      },
      "PolicyEntry" : {
        "type" : "object",
        "properties" : {
          "id" : {
            "type" : "string"
          },
          "code" : {
            "type" : "string"
          },
          "description" : {
            "type" : "string"
          },
          "state" : {
            "type" : "string",
            "enum" : [ "ENABLED", "DISABLED" ]
          },
          "createdAt" : {
            "type" : "integer",
            "format" : "int64"
          },
          "updatedAt" : {
            "type" : "integer",
            "format" : "int64"
          }
        }
      },
      "PolicyAggregateLimits" : {
        "type" : "object",
        "properties" : {
          "action" : {
            "type" : "string",
            "enum" : [ "DEBIT", "CREDIT", "DEBIT_REVERSAL", "CREDIT_REVERSAL" ]
          },
          "txnCategoryCode" : {
            "type" : "string"
          },
          "aggregateExpressionCode" : {
            "type" : "string"
          },
          "dailyLimit" : {
            "type" : "integer",
            "format" : "int64"
          },
          "weeklyLimit" : {
            "type" : "integer",
            "format" : "int64"
          },
          "monthlyLimit" : {
            "type" : "integer",
            "format" : "int64"
          },
          "quarterlyLimit" : {
            "type" : "integer",
            "format" : "int64"
          },
          "yearlyLimit" : {
            "type" : "integer",
            "format" : "int64"
          },
          "errorCode" : {
            "type" : "string"
          }
        }
      },
      "PolicyBalanceLimits" : {
        "type" : "object",
        "properties" : {
          "action" : {
            "type" : "string",
            "enum" : [ "DEBIT", "CREDIT", "DEBIT_REVERSAL", "CREDIT_REVERSAL" ]
          },
          "txnCategoryCode" : {
            "type" : "string"
          },
          "minRequiredBalanceBeforeTxn" : {
            "type" : "integer",
            "format" : "int64"
          },
          "maxAllowedBalanceBeforeTxn" : {
            "type" : "integer",
            "format" : "int64"
          },
          "minRequiredBalanceAfterTxn" : {
            "type" : "integer",
            "format" : "int64"
          },
          "maxAllowedBalanceAfterTxn" : {
            "type" : "integer",
            "format" : "int64"
          },
          "errorCode" : {
            "type" : "string"
          }
        }
      },
      "PolicyTxnRule" : {
        "type" : "object",
        "properties" : {
          "id" : {
            "type" : "integer",
            "format" : "int64"
          },
          "policyVersionID" : {
            "type" : "integer",
            "format" : "int64"
          },
          "action" : {
            "type" : "string",
            "enum" : [ "DEBIT", "CREDIT", "DEBIT_REVERSAL", "CREDIT_REVERSAL" ]
          },
          "categoryCode" : {
            "type" : "string"
          },
          "minRequiredAmount" : {
            "type" : "integer",
            "format" : "int64"
          },
          "maxAllowedAmount" : {
            "type" : "integer",
            "format" : "int64"
          },
          "errorCode" : {
            "type" : "string"
          }
        }
      },
      "PolicyTxnLimits" : {
        "type" : "object",
        "properties" : {
          "action" : {
            "type" : "string",
            "enum" : [ "DEBIT", "CREDIT", "DEBIT_REVERSAL", "CREDIT_REVERSAL" ]
          },
          "txnCategoryCode" : {
            "type" : "string"
          },
          "minRequiredTxnAmount" : {
            "type" : "integer",
            "format" : "int64"
          },
          "maxAllowedTxnAmount" : {
            "type" : "integer",
            "format" : "int64"
          },
          "errorCode" : {
            "type" : "string"
          }
        }
      },
      "PolicyTxnConstraints" : {
        "type" : "object",
        "properties" : {
          "action" : {
            "type" : "string",
            "enum" : [ "DEBIT", "CREDIT", "DEBIT_REVERSAL", "CREDIT_REVERSAL" ]
          },
          "allowedTxnCategoryCodes" : {
            "type" : "array",
            "items" : { 
              "type" : "string"
            },
          },
          "disallowedTxnCategoryCodes" : {
            "type" : "array",
            "items" : { 
              "type" : "string"
            },
          },
          "allowedTimeSlices" : {
            "type" : "array",
            "items" : {
              "type" : "string"
            }
          },
          "disallowedTimeSlices" : {
            "type" : "array",
            "items" : {
              "type" : "string"
            }
          },
          "errorCode" : {
            "type" : "string"
          }
        }
      },
      "TransactionPolicyResponse" : {
        "type" : "object",
        "properties" : {
          "id" : {
            "type" : "string"
          },
          "status" : {
            "type" : "string",
            "enum" : [ "ENABLED", "DISABLED" ]
          },
          "ifiId" : {
            "type" : "integer",
            "format" : "int64"
          },
          "code" : {
            "type" : "string"
          },
          "description" : {
            "type" : "string"
          },
          "txnConstraints" : {
            "type" : "array",
            "items" : {
              "$ref" : "#/components/schemas/PolicyTxnConstraints"
            }
          },
          "txnLimits" : {
            "type" : "array",
            "items" : {
              "$ref" : "#/components/schemas/PolicyTxnLimits"
            }
          },
          "balanceLimits" : {
            "type" : "array",
            "items" : {
              "$ref" : "#/components/schemas/PolicyBalanceLimits"
            }
          },
          "volumeLimits" : {
            "type" : "array",
            "items" : {
              "$ref" : "#/components/schemas/PolicyAggregateLimits"
            }
          },
          "velocityLimits" : {
            "type" : "array",
            "items" : {
              "$ref" : "#/components/schemas/PolicyAggregateLimits"
            }
          },
          "validFrom" : {
            "type" : "integer",
            "format" : "int64",
            "description": "epoch timestamp in Millis"
          },
          "validUntil" : {
            "type" : "integer",
            "format" : "int64",
            "description": "epoch timestamp in Millis"
          },
          "policyViolationAction" : {
            "type" : "string",
            "enum" : [ "DECLINE", "NOTIFY", "DECLINE_AND_NOTIFY" ]
          },
          "attributes" : {
            "type" : "object"
          }
        }
      },
      
      "TransactionPolicyState" : {
        "type" : "object",
        "properties" : {
  
         
         
        }
      },
      
      
      
      "CreateTransactionPolicyRequest" : {
        "type" : "object",
        "properties" : {
          "ifiId" : {
            "type" : "integer",
            "format" : "int64"
          },
          "code" : {
            "type" : "string"
          },
          "description" : {
            "type" : "string"
          },
          "txnConstraints" : {
            "type" : "array",
            "items" : {
              "$ref" : "#/components/schemas/PolicyTxnConstraints"
            }
          },
          "txnLimits" : {
            "type" : "array",
            "items" : {
              "$ref" : "#/components/schemas/PolicyTxnLimits"
            }
          },
          "balanceLimits" : {
            "type" : "array",
            "items" : {
              "$ref" : "#/components/schemas/PolicyBalanceLimits"
            }
          },
          "volumeLimits" : {
            "type" : "array",
            "items" : {
              "$ref" : "#/components/schemas/PolicyAggregateLimits"
            }
          },
          "velocityLimits" : {
            "type" : "array",
            "items" : {
              "$ref" : "#/components/schemas/PolicyAggregateLimits"
            }
          },
          "validFrom" : {
            "type" : "integer",
            "format" : "int64",
            "description": "epoch timestamp in Millis"
          },
          "validUntil" : {
            "type" : "integer",
            "format" : "int64",
            "description": "epoch timestamp in Millis"
          },
          "policyViolationAction" : {
            "type" : "string",
            "enum" : [ "DECLINE", "NOTIFY", "DECLINE_AND_NOTIFY" ]
          },
          "attributes" : {
            "type" : "object"
          }
        }
      },
       "CreateTransactionPolicyRequestAH" : {
        "type" : "object",
        "properties" : {
          "ifiId" : {
            "type" : "integer",
            "format" : "int64"
          },
          
        }
      },
      "MapTransactionPolicyRequestAH" : {
        "type" : "object",
        "properties" : {
          "policyID" : {
            "type" : "string",
            "description":"Unique identifier of the policy to be mapped."
          },
          
        }
      },
      
      
      
      "UpdateTransactionPolicyRequest" : {
        "type" : "object",
        "properties" : {
          "ifiId" : {
            "type" : "integer",
            "format" : "int64"
          },
          "code" : {
            "type" : "string"
          },
          "description" : {
            "type" : "string"
          },
          "status" : {
            "type" : "string",
            "enum" : [ "ENABLED", "DISABLED" ]
          },
          "txnConstraints" : {
            "type" : "array",
            "items" : {
              "$ref" : "#/components/schemas/PolicyTxnConstraints"
            }
          },
          "txnLimits" : {
            "type" : "array",
            "items" : {
              "$ref" : "#/components/schemas/PolicyTxnLimits"
            }
          },
          "balanceLimits" : {
            "type" : "array",
            "items" : {
              "$ref" : "#/components/schemas/PolicyBalanceLimits"
            }
          },
          "aggregateLimits" : {
            "type" : "array",
            "items" : {
              "$ref" : "#/components/schemas/PolicyAggregateLimits"
            }
          },
          "validFrom" : {
            "type" : "integer",
            "format" : "int64",
            "description": "epoch timestamp in Millis"
          },
          "validUntil" : {
            "type" : "integer",
            "format" : "int64",
            "description": "epoch timestamp in Millis"
          },
          "policyViolationAction" : {
            "type" : "string",
            "enum" : [ "DECLINE", "NOTIFY", "DECLINE_AND_NOTIFY" ]
          },
          "attributes" : {
            "type" : "object"
          }
        }
      },
      "ErrorCode" : {
        "type" : "object",
        "properties" : {
          "code" : {
            "type" : "string"
          },
          "description" : {
            "type" : "string"
          }
        }
      },
      "TxnCategoryMeta" : {
        "type" : "object",
        "properties" : {
          "code" : {
            "type" : "string"
          },
          "description" : {
            "type" : "string"
          }
        }
      },
      "TxnCategory" : {
        "type" : "object",
        "properties" : {
          "ifiId" : {
            "type" : "integer",
            "format" : "int64"
          },
          "code" : {
            "type" : "string"
          },
          "description" : {
            "type" : "string"
          },
          "transactionAttributes" : {
            "type" : "array",
            "items" : {
              "$ref" : "#/components/schemas/TxnCategoryAttribute"
            }
          }
        }
      },
      "TxnCategoryAttribute" : {
        "type" : "object",
        "properties" : {
          "attributeKey" : {
            "type" : "string"
          },
          "attributeValue" : {
            "type" : "string"
          },
          "attributeValueComparator" : {
            "type" : "string",
            "enum" : [ "EQUALS", "CONTAINS" ]
          }
        }
      },
      "AggregateExpressionMeta" : {
        "type" : "object",
        "properties" : {
          "code" : {
            "type" : "string"
          },
          "description" : {
            "type" : "string"
          }
        }
      },
      "AggregateExpression" : {
        "type" : "object",
        "properties" : {
          "ifiId" : {
            "type" : "integer",
            "format" : "int64"
          },
          "code" : {
            "type" : "string"
          },
          "description" : {
            "type" : "string"
          },
          "expression" : {
            "type" : "string"
          }
        }
      },
      "GetTransactionPolicyErrorCodeListResponse" : {
        "type" : "object",
        "properties" : {
          "errorCodes" : {
            "type" : "array",
            "items" : {
              "$ref" : "#/components/schemas/ErrorCode"
            }
          }
        }
      },
      "UpdateTxnCategoryRequest" : {
        "type" : "object",
        "properties" : {
          "description" : {
            "type" : "string"
          },
          "transactionAttributes" : {
            "type" : "array",
            "items" : {
              "$ref" : "#/components/schemas/TxnCategoryAttribute"
            }
          }
        }
      },
      "GetTxnCategoriesResponse" : {
        "type" : "object",
        "properties" : {
          "transactionCategories" : {
            "type" : "array",
            "items" : {
              "$ref" : "#/components/schemas/TxnCategoryMeta"
            }
          }
        }
      },
      "UpdateAggregateExpressionRequest" : {
        "type" : "object",
        "properties" : {
          "description" : {
            "type" : "string"
          },
          "expression" : {
            "type" : "string"
          }
        }
      },
      "GetAggregateExpressionsResponse" : {
        "type" : "object",
        "properties" : {
          "aggregateExpressions" : {
            "type" : "array",
            "items" : {
              "$ref" : "#/components/schemas/AggregateExpressionMeta"
            }
          }
        }
      },
      "PolicyMappingResponse" : {
        "type" : "object",
        "properties" : {
          "headers" : {
            "type" : "object",
            "additionalProperties" : {
              "type" : "string"
            }
          },
          "id" : {
            "type" : "string"
          },
          "ifiID" : {
            "type" : "integer",
            "format" : "int64"
          },
          "entityID" : {
            "type" : "string"
          },
          "policyEntityType" : {
            "type" : "string",
            "enum" : [ "PRODUCT_FAMILY", "PRODUCT", "PROGRAM", "RESOURCE_PRODUCT", "WALLET_PRODUCT" ]
          },
          "policyID" : {
            "type" : "string"
          },
          "policyType" : {
            "type" : "string",
            "enum" : [ "TRANSACTION_POLICY", "CARD_DESIGN_POLICY", "ISSUANCE_POLICY", "COUPON_ACCOUNTING_POLICY", "NOTIFICATION_POLICY", "FEE_CHARGES_POLICY", "INTEREST_POLICY", "ACCOUNT_DISCOVERY_POLICY" ]
          },
          "attributes" : {
            "type" : "object",
            "additionalProperties" : {
              "type" : "object"
            }
          },
          "createdAt" : {
            "type" : "integer",
            "format" : "int64"
          },
          "updatedAt" : {
            "type" : "integer",
            "format" : "int64"
          }
        }
      },
      "CreatePolicyMappingRequest" : {
        "type" : "object",
        "properties" : {
          "headers" : {
            "type" : "object",
            "additionalProperties" : {
              "type" : "string"
            }
          },
          "ifiID" : {
            "type" : "integer",
            "format" : "int64"
          },
          "entityID" : {
            "type" : "string"
          },
          "policyEntityType" : {
            "type" : "string",
            "enum" : [ "PRODUCT_FAMILY", "PRODUCT", "PROGRAM", "RESOURCE_PRODUCT", "WALLET_PRODUCT" ]
          },
          "policyID" : {
            "type" : "string"
          },
          "policyType" : {
            "type" : "string",
            "enum" : [ "TRANSACTION_POLICY", "CARD_DESIGN_POLICY", "ISSUANCE_POLICY", "COUPON_ACCOUNTING_POLICY", "NOTIFICATION_POLICY", "FEE_CHARGES_POLICY", "INTEREST_POLICY", "ACCOUNT_DISCOVERY_POLICY" ]
          },
          "attributes" : {
            "type" : "object",
            "additionalProperties" : {
              "type" : "object"
            }
          }
        }
      },
      "GetPolicyMappingsResponse" : {
        "type" : "object",
        "properties" : {
          "headers" : {
            "type" : "object",
            "additionalProperties" : {
              "type" : "string"
            }
          },
          "policyMappingResponseList" : {
            "type" : "array",
            "items" : {
              "$ref" : "#/components/schemas/PolicyMappingResponse"
            }
          }
        }
      },
      "GetPolicyMappingsRequest" : {
        "type" : "object",
        "properties" : {
          "headers" : {
            "type" : "object",
            "additionalProperties" : {
              "type" : "string"
            }
          },
          "ifiID" : {
            "type" : "integer",
            "format" : "int64"
          },
          "entityID" : {
            "type" : "string"
          },
          "policyEntityType" : {
            "type" : "string",
            "enum" : [ "PRODUCT_FAMILY", "PRODUCT", "PROGRAM", "RESOURCE_PRODUCT", "WALLET_PRODUCT" ]
          },
          "policyID" : {
            "type" : "string"
          },
          "policyType" : {
            "type" : "string",
            "enum" : [ "TRANSACTION_POLICY", "CARD_DESIGN_POLICY", "ISSUANCE_POLICY", "COUPON_ACCOUNTING_POLICY", "NOTIFICATION_POLICY", "FEE_CHARGES_POLICY", "INTEREST_POLICY", "ACCOUNT_DISCOVERY_POLICY" ]
          }
        }
      }
    }
  }
}




On this page:

Need Help?

Contact us at fusion-support@zeta.tech or call us on 080-6690 5995.