# coding: utf-8

"""
    Synctera API

    <h2>Let's build something great.</h2><p>Welcome to the official reference documentation for Synctera APIs. Our APIs are the best way to automate your company's banking needs and are designed to be easy to understand and implement.</p><p>We're continuously growing this library and what you see here is just the start, but if you need something specific or have a question, <a class='text-blue-600' href='https://synctera.com/contact' target='_blank' rel='noreferrer'>contact us</a>.</p>   # noqa: E501

    The version of the OpenAPI document: 0.32.0.dev6
    Generated by: https://openapi-generator.tech
"""

from datetime import date, datetime  # noqa: F401
import decimal  # noqa: F401
import functools  # noqa: F401
import io  # noqa: F401
import re  # noqa: F401
import typing  # noqa: F401
import typing_extensions  # noqa: F401
import uuid  # noqa: F401

import frozendict  # noqa: F401

from synctera_client import schemas  # noqa: F401


class ReturnAch(
    schemas.DictSchema
):
    """NOTE: This class is auto generated by OpenAPI Generator.
    Ref: https://openapi-generator.tech

    Do not edit the class manually.

    Regular return
    """


    class MetaOapg:
        required = {
            "type",
        }
        
        class properties:
            
            
            class type(
                schemas.EnumBase,
                schemas.StrSchema
            ):
                
                @schemas.classproperty
                def INSUFFICIENT_FUNDS(cls):
                    return cls("insufficient_funds")
                
                @schemas.classproperty
                def ACC_CLOSED(cls):
                    return cls("acc_closed")
                
                @schemas.classproperty
                def ACC_NOT_FOUND(cls):
                    return cls("acc_not_found")
                
                @schemas.classproperty
                def ACC_INVALID(cls):
                    return cls("acc_invalid")
                
                @schemas.classproperty
                def UNAUTHORIZED_CORP_DEBIT(cls):
                    return cls("unauthorized_corp_debit")
                
                @schemas.classproperty
                def RETURN_REQUESTED(cls):
                    return cls("return_requested")
                
                @schemas.classproperty
                def AUTH_REVOKED(cls):
                    return cls("auth_revoked")
                
                @schemas.classproperty
                def PAYMENT_STOPPED(cls):
                    return cls("payment_stopped")
                
                @schemas.classproperty
                def UNCOLLECTED_FUNDS(cls):
                    return cls("uncollected_funds")
                
                @schemas.classproperty
                def UNAUTHORIZED_DEBIT(cls):
                    return cls("unauthorized_debit")
                
                @schemas.classproperty
                def FAILED_TERMS(cls):
                    return cls("failed_terms")
                
                @schemas.classproperty
                def ACCOUNT_SOLD(cls):
                    return cls("account_sold")
                
                @schemas.classproperty
                def ACC_FROZEN(cls):
                    return cls("acc_frozen")
                
                @schemas.classproperty
                def FIELDS_NOT_PROCESSABLE(cls):
                    return cls("fields_not_processable")
                
                @schemas.classproperty
                def IMPROPER_EFFECTIVE_DATE(cls):
                    return cls("improper_effective_date")
                
                @schemas.classproperty
                def NON_TRANSACTION_ACCOUNT(cls):
                    return cls("non_transaction_account")
                
                @schemas.classproperty
                def CREDIT_REFUSED(cls):
                    return cls("credit_refused")
                
                @schemas.classproperty
                def DUPLICATE_TRANSACTION(cls):
                    return cls("duplicate_transaction")
                
                @schemas.classproperty
                def CORP_RECEIVER_UNAUTHORIZED(cls):
                    return cls("corp_receiver_unauthorized")
                
                @schemas.classproperty
                def PERMISSIBLE_RETURN(cls):
                    return cls("permissible_return")
                
                @schemas.classproperty
                def SOURCE_DOCUMENT_PRESENTED(cls):
                    return cls("source_document_presented")
                
                @schemas.classproperty
                def SOURCE_DOCUMENT_STOP_PAYMENT(cls):
                    return cls("source_document_stop_payment")
                
                @schemas.classproperty
                def IMPROPER_SOURCE_DOCUMENT(cls):
                    return cls("improper_source_document")
                
                @schemas.classproperty
                def STATE_LAW_AFFECTING_ACCEPTANCE(cls):
                    return cls("state_law_affecting_acceptance")
                
                @schemas.classproperty
                def INELIGIBLE_OR_IMPROPER_ENTRY(cls):
                    return cls("ineligible_or_improper_entry")
                
                @schemas.classproperty
                def ITEM_STOP_PAYMENT(cls):
                    return cls("item_stop_payment")
            __annotations__ = {
                "type": type,
            }
    
    type: MetaOapg.properties.type
    
    @typing.overload
    def __getitem__(self, name: typing_extensions.Literal["type"]) -> MetaOapg.properties.type: ...
    
    @typing.overload
    def __getitem__(self, name: str) -> schemas.UnsetAnyTypeSchema: ...
    
    def __getitem__(self, name: typing.Union[typing_extensions.Literal["type", ], str]):
        # dict_instance[name] accessor
        return super().__getitem__(name)
    
    
    @typing.overload
    def get_item_oapg(self, name: typing_extensions.Literal["type"]) -> MetaOapg.properties.type: ...
    
    @typing.overload
    def get_item_oapg(self, name: str) -> typing.Union[schemas.UnsetAnyTypeSchema, schemas.Unset]: ...
    
    def get_item_oapg(self, name: typing.Union[typing_extensions.Literal["type", ], str]):
        return super().get_item_oapg(name)
    

    def __new__(
        cls,
        *_args: typing.Union[dict, frozendict.frozendict, ],
        type: typing.Union[MetaOapg.properties.type, str, ],
        _configuration: typing.Optional[schemas.Configuration] = None,
        **kwargs: typing.Union[schemas.AnyTypeSchema, dict, frozendict.frozendict, str, date, datetime, uuid.UUID, int, float, decimal.Decimal, None, list, tuple, bytes],
    ) -> 'ReturnAch':
        return super().__new__(
            cls,
            *_args,
            type=type,
            _configuration=_configuration,
            **kwargs,
        )
