    {- |
    Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
    License    : LGPL-2.1
    Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

    Support for UNIX-domain (also known as local) sockets.

    UNIX domain sockets are generally visible in the filesystem.
    However, some systems support abstract socket names which are not
    visible in the filesystem and not affected by the filesystem
    permissions, visibility, etc. Currently this is only supported
    under Linux. If you attempt to use abstract sockets on other
    systems, function calls may return 'GI.Gio.Enums.IOErrorEnumNotSupported'
    errors. You can use 'GI.Gio.Objects.UnixSocketAddress.unixSocketAddressAbstractNamesSupported'
    to see if abstract names are supported.

    Note that @\<gio\/gunixsocketaddress.h>@ belongs to the UNIX-specific GIO
    interfaces, thus you have to use the @gio-unix-2.0.pc@ pkg-config file
    when using it.
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.Gio.Objects.UnixSocketAddress
        (

    -- * Exported types
        UnixSocketAddress(..)                   ,
        IsUnixSocketAddress                     ,
        toUnixSocketAddress                     ,
        noUnixSocketAddress                     ,

     -- * Methods
    -- ** abstractNamesSupported #method:abstractNamesSupported#

        unixSocketAddressAbstractNamesSupported ,

    -- ** getAddressType #method:getAddressType#

    #if ENABLE_OVERLOADING
        UnixSocketAddressGetAddressTypeMethodInfo,
    #endif
        unixSocketAddressGetAddressType         ,

    -- ** getIsAbstract #method:getIsAbstract#

    #if ENABLE_OVERLOADING
        UnixSocketAddressGetIsAbstractMethodInfo,
    #endif
        unixSocketAddressGetIsAbstract          ,

    -- ** getPath #method:getPath#

    #if ENABLE_OVERLOADING
        UnixSocketAddressGetPathMethodInfo      ,
    #endif
        unixSocketAddressGetPath                ,

    -- ** getPathLen #method:getPathLen#

    #if ENABLE_OVERLOADING
        UnixSocketAddressGetPathLenMethodInfo   ,
    #endif
        unixSocketAddressGetPathLen             ,

    -- ** new #method:new#

        unixSocketAddressNew                    ,

    -- ** newAbstract #method:newAbstract#

        unixSocketAddressNewAbstract            ,

    -- ** newWithType #method:newWithType#

        unixSocketAddressNewWithType            ,

     -- * Properties
    -- ** abstract #attr:abstract#
    {- | Whether or not this is an abstract address
    -}
    #if ENABLE_OVERLOADING
        UnixSocketAddressAbstractPropertyInfo   ,
    #endif
        constructUnixSocketAddressAbstract      ,
        getUnixSocketAddressAbstract            ,
    #if ENABLE_OVERLOADING
        unixSocketAddressAbstract               ,
    #endif

    -- ** addressType #attr:addressType#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        UnixSocketAddressAddressTypePropertyInfo,
    #endif
        constructUnixSocketAddressAddressType   ,
        getUnixSocketAddressAddressType         ,
    #if ENABLE_OVERLOADING
        unixSocketAddressAddressType            ,
    #endif

    -- ** path #attr:path#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        UnixSocketAddressPathPropertyInfo       ,
    #endif
        constructUnixSocketAddressPath          ,
        getUnixSocketAddressPath                ,
    #if ENABLE_OVERLOADING
        unixSocketAddressPath                   ,
    #endif

    -- ** pathAsArray #attr:pathAsArray#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        UnixSocketAddressPathAsArrayPropertyInfo,
    #endif
        constructUnixSocketAddressPathAsArray   ,
        getUnixSocketAddressPathAsArray         ,
    #if ENABLE_OVERLOADING
        unixSocketAddressPathAsArray            ,
    #endif

        ) where

    import Data.GI.Base.ShortPrelude
    import qualified Data.GI.Base.ShortPrelude as SP
    import qualified Data.GI.Base.Overloading as O
    import qualified Prelude as P

    import qualified Data.GI.Base.Attributes as GI.Attributes
    import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
    import qualified Data.GI.Base.GError as B.GError
    import qualified Data.GI.Base.GVariant as B.GVariant
    import qualified Data.GI.Base.GValue as B.GValue
    import qualified Data.GI.Base.GParamSpec as B.GParamSpec
    import qualified Data.GI.Base.CallStack as B.CallStack
    import qualified Data.Text as T
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP

    import qualified GI.GObject.Objects.Object as GObject.Object
    import {-# SOURCE #-} qualified GI.Gio.Enums as Gio.Enums
    import {-# SOURCE #-} qualified GI.Gio.Interfaces.SocketConnectable as Gio.SocketConnectable
    import {-# SOURCE #-} qualified GI.Gio.Objects.SocketAddress as Gio.SocketAddress

    -- | Memory-managed wrapper type.
    newtype UnixSocketAddress = UnixSocketAddress (ManagedPtr UnixSocketAddress)
    foreign import ccall "g_unix_socket_address_get_type"
        c_g_unix_socket_address_get_type :: IO GType

    instance GObject UnixSocketAddress where
        gobjectType _ = c_g_unix_socket_address_get_type

    -- | Type class for types which can be safely cast to `UnixSocketAddress`, for instance with `toUnixSocketAddress`.
    class GObject o => IsUnixSocketAddress o
    #if MIN_VERSION_base(4,9,0)
    instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError UnixSocketAddress a) =>
        IsUnixSocketAddress a
    #endif
    instance IsUnixSocketAddress UnixSocketAddress
    instance Gio.SocketAddress.IsSocketAddress UnixSocketAddress
    instance GObject.Object.IsObject UnixSocketAddress
    instance Gio.SocketConnectable.IsSocketConnectable UnixSocketAddress

    -- | Cast to `UnixSocketAddress`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
    toUnixSocketAddress :: (MonadIO m, IsUnixSocketAddress o) => o -> m UnixSocketAddress
    toUnixSocketAddress = liftIO . unsafeCastTo UnixSocketAddress

    -- | A convenience alias for `Nothing` :: `Maybe` `UnixSocketAddress`.
    noUnixSocketAddress :: Maybe UnixSocketAddress
    noUnixSocketAddress = Nothing

    #if ENABLE_OVERLOADING
    type family ResolveUnixSocketAddressMethod (t :: Symbol) (o :: *) :: * where
        ResolveUnixSocketAddressMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveUnixSocketAddressMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveUnixSocketAddressMethod "enumerate" o = Gio.SocketConnectable.SocketConnectableEnumerateMethodInfo
        ResolveUnixSocketAddressMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveUnixSocketAddressMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveUnixSocketAddressMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveUnixSocketAddressMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveUnixSocketAddressMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveUnixSocketAddressMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveUnixSocketAddressMethod "proxyEnumerate" o = Gio.SocketConnectable.SocketConnectableProxyEnumerateMethodInfo
        ResolveUnixSocketAddressMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveUnixSocketAddressMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveUnixSocketAddressMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveUnixSocketAddressMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveUnixSocketAddressMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveUnixSocketAddressMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveUnixSocketAddressMethod "toNative" o = Gio.SocketAddress.SocketAddressToNativeMethodInfo
        ResolveUnixSocketAddressMethod "toString" o = Gio.SocketConnectable.SocketConnectableToStringMethodInfo
        ResolveUnixSocketAddressMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveUnixSocketAddressMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveUnixSocketAddressMethod "getAddressType" o = UnixSocketAddressGetAddressTypeMethodInfo
        ResolveUnixSocketAddressMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveUnixSocketAddressMethod "getFamily" o = Gio.SocketAddress.SocketAddressGetFamilyMethodInfo
        ResolveUnixSocketAddressMethod "getIsAbstract" o = UnixSocketAddressGetIsAbstractMethodInfo
        ResolveUnixSocketAddressMethod "getNativeSize" o = Gio.SocketAddress.SocketAddressGetNativeSizeMethodInfo
        ResolveUnixSocketAddressMethod "getPath" o = UnixSocketAddressGetPathMethodInfo
        ResolveUnixSocketAddressMethod "getPathLen" o = UnixSocketAddressGetPathLenMethodInfo
        ResolveUnixSocketAddressMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveUnixSocketAddressMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveUnixSocketAddressMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveUnixSocketAddressMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveUnixSocketAddressMethod l o = O.MethodResolutionFailed l o

    instance (info ~ ResolveUnixSocketAddressMethod t UnixSocketAddress, O.MethodInfo info UnixSocketAddress p) => O.IsLabelProxy t (UnixSocketAddress -> p) where
        fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

    #if MIN_VERSION_base(4,9,0)
    instance (info ~ ResolveUnixSocketAddressMethod t UnixSocketAddress, O.MethodInfo info UnixSocketAddress p) => O.IsLabel t (UnixSocketAddress -> p) where
    #if MIN_VERSION_base(4,10,0)
        fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
    #else
        fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
    #endif
    #endif

    #endif

    -- VVV Prop "abstract"
       -- Type: TBasicType TBoolean
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
       -- Nullable: (Nothing,Nothing)

    {- |
    Get the value of the “@abstract@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' unixSocketAddress #abstract
    @
    -}
    getUnixSocketAddressAbstract :: (MonadIO m, IsUnixSocketAddress o) => o -> m Bool
    getUnixSocketAddressAbstract obj = liftIO $ getObjectPropertyBool obj "abstract"

    {- |
    Construct a `GValueConstruct` with valid value for the “@abstract@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructUnixSocketAddressAbstract :: (IsUnixSocketAddress o) => Bool -> IO (GValueConstruct o)
    constructUnixSocketAddressAbstract val = constructObjectPropertyBool "abstract" val

    #if ENABLE_OVERLOADING
    data UnixSocketAddressAbstractPropertyInfo
    instance AttrInfo UnixSocketAddressAbstractPropertyInfo where
        type AttrAllowedOps UnixSocketAddressAbstractPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
        type AttrSetTypeConstraint UnixSocketAddressAbstractPropertyInfo = (~) Bool
        type AttrBaseTypeConstraint UnixSocketAddressAbstractPropertyInfo = IsUnixSocketAddress
        type AttrGetType UnixSocketAddressAbstractPropertyInfo = Bool
        type AttrLabel UnixSocketAddressAbstractPropertyInfo = "abstract"
        type AttrOrigin UnixSocketAddressAbstractPropertyInfo = UnixSocketAddress
        attrGet _ = getUnixSocketAddressAbstract
        attrSet _ = undefined
        attrConstruct _ = constructUnixSocketAddressAbstract
        attrClear _ = undefined
    #endif

    -- VVV Prop "address-type"
       -- Type: TInterface (Name {namespace = "Gio", name = "UnixSocketAddressType"})
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
       -- Nullable: (Just False,Nothing)

    {- |
    Get the value of the “@address-type@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' unixSocketAddress #addressType
    @
    -}
    getUnixSocketAddressAddressType :: (MonadIO m, IsUnixSocketAddress o) => o -> m Gio.Enums.UnixSocketAddressType
    getUnixSocketAddressAddressType obj = liftIO $ getObjectPropertyEnum obj "address-type"

    {- |
    Construct a `GValueConstruct` with valid value for the “@address-type@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructUnixSocketAddressAddressType :: (IsUnixSocketAddress o) => Gio.Enums.UnixSocketAddressType -> IO (GValueConstruct o)
    constructUnixSocketAddressAddressType val = constructObjectPropertyEnum "address-type" val

    #if ENABLE_OVERLOADING
    data UnixSocketAddressAddressTypePropertyInfo
    instance AttrInfo UnixSocketAddressAddressTypePropertyInfo where
        type AttrAllowedOps UnixSocketAddressAddressTypePropertyInfo = '[ 'AttrConstruct, 'AttrGet]
        type AttrSetTypeConstraint UnixSocketAddressAddressTypePropertyInfo = (~) Gio.Enums.UnixSocketAddressType
        type AttrBaseTypeConstraint UnixSocketAddressAddressTypePropertyInfo = IsUnixSocketAddress
        type AttrGetType UnixSocketAddressAddressTypePropertyInfo = Gio.Enums.UnixSocketAddressType
        type AttrLabel UnixSocketAddressAddressTypePropertyInfo = "address-type"
        type AttrOrigin UnixSocketAddressAddressTypePropertyInfo = UnixSocketAddress
        attrGet _ = getUnixSocketAddressAddressType
        attrSet _ = undefined
        attrConstruct _ = constructUnixSocketAddressAddressType
        attrClear _ = undefined
    #endif

    -- VVV Prop "path"
       -- Type: TBasicType TUTF8
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
       -- Nullable: (Just False,Nothing)

    {- |
    Get the value of the “@path@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' unixSocketAddress #path
    @
    -}
    getUnixSocketAddressPath :: (MonadIO m, IsUnixSocketAddress o) => o -> m T.Text
    getUnixSocketAddressPath obj = liftIO $ checkUnexpectedNothing "getUnixSocketAddressPath" $ getObjectPropertyString obj "path"

    {- |
    Construct a `GValueConstruct` with valid value for the “@path@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructUnixSocketAddressPath :: (IsUnixSocketAddress o) => T.Text -> IO (GValueConstruct o)
    constructUnixSocketAddressPath val = constructObjectPropertyString "path" (Just val)

    #if ENABLE_OVERLOADING
    data UnixSocketAddressPathPropertyInfo
    instance AttrInfo UnixSocketAddressPathPropertyInfo where
        type AttrAllowedOps UnixSocketAddressPathPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint UnixSocketAddressPathPropertyInfo = (~) T.Text
        type AttrBaseTypeConstraint UnixSocketAddressPathPropertyInfo = IsUnixSocketAddress
        type AttrGetType UnixSocketAddressPathPropertyInfo = T.Text
        type AttrLabel UnixSocketAddressPathPropertyInfo = "path"
        type AttrOrigin UnixSocketAddressPathPropertyInfo = UnixSocketAddress
        attrGet _ = getUnixSocketAddressPath
        attrSet _ = undefined
        attrConstruct _ = constructUnixSocketAddressPath
        attrClear _ = undefined
    #endif

    -- VVV Prop "path-as-array"
       -- Type: TByteArray
       -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
       -- Nullable: (Nothing,Nothing)

    {- |
    Get the value of the “@path-as-array@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' unixSocketAddress #pathAsArray
    @
    -}
    getUnixSocketAddressPathAsArray :: (MonadIO m, IsUnixSocketAddress o) => o -> m (Maybe ByteString)
    getUnixSocketAddressPathAsArray obj = liftIO $ getObjectPropertyByteArray obj "path-as-array"

    {- |
    Construct a `GValueConstruct` with valid value for the “@path-as-array@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructUnixSocketAddressPathAsArray :: (IsUnixSocketAddress o) => ByteString -> IO (GValueConstruct o)
    constructUnixSocketAddressPathAsArray val = constructObjectPropertyByteArray "path-as-array" (Just val)

    #if ENABLE_OVERLOADING
    data UnixSocketAddressPathAsArrayPropertyInfo
    instance AttrInfo UnixSocketAddressPathAsArrayPropertyInfo where
        type AttrAllowedOps UnixSocketAddressPathAsArrayPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
        type AttrSetTypeConstraint UnixSocketAddressPathAsArrayPropertyInfo = (~) ByteString
        type AttrBaseTypeConstraint UnixSocketAddressPathAsArrayPropertyInfo = IsUnixSocketAddress
        type AttrGetType UnixSocketAddressPathAsArrayPropertyInfo = (Maybe ByteString)
        type AttrLabel UnixSocketAddressPathAsArrayPropertyInfo = "path-as-array"
        type AttrOrigin UnixSocketAddressPathAsArrayPropertyInfo = UnixSocketAddress
        attrGet _ = getUnixSocketAddressPathAsArray
        attrSet _ = undefined
        attrConstruct _ = constructUnixSocketAddressPathAsArray
        attrClear _ = undefined
    #endif

    #if ENABLE_OVERLOADING
    instance O.HasAttributeList UnixSocketAddress
    type instance O.AttributeList UnixSocketAddress = UnixSocketAddressAttributeList
    type UnixSocketAddressAttributeList = ('[ '("abstract", UnixSocketAddressAbstractPropertyInfo), '("addressType", UnixSocketAddressAddressTypePropertyInfo), '("family", Gio.SocketAddress.SocketAddressFamilyPropertyInfo), '("path", UnixSocketAddressPathPropertyInfo), '("pathAsArray", UnixSocketAddressPathAsArrayPropertyInfo)] :: [(Symbol, *)])
    #endif

    #if ENABLE_OVERLOADING
    unixSocketAddressAbstract :: AttrLabelProxy "abstract"
    unixSocketAddressAbstract = AttrLabelProxy

    unixSocketAddressAddressType :: AttrLabelProxy "addressType"
    unixSocketAddressAddressType = AttrLabelProxy

    unixSocketAddressPath :: AttrLabelProxy "path"
    unixSocketAddressPath = AttrLabelProxy

    unixSocketAddressPathAsArray :: AttrLabelProxy "pathAsArray"
    unixSocketAddressPathAsArray = AttrLabelProxy

    #endif

    #if ENABLE_OVERLOADING
    type instance O.SignalList UnixSocketAddress = UnixSocketAddressSignalList
    type UnixSocketAddressSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

    #endif

    -- method UnixSocketAddress::new
    -- method type : Constructor
    -- Args : [Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the socket path", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gio", name = "UnixSocketAddress"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_unix_socket_address_new" g_unix_socket_address_new ::
        CString ->                              -- path : TBasicType TUTF8
        IO (Ptr UnixSocketAddress)

    {- |
    Creates a new 'GI.Gio.Objects.UnixSocketAddress.UnixSocketAddress' for /@path@/.

    To create abstract socket addresses, on systems that support that,
    use 'GI.Gio.Objects.UnixSocketAddress.unixSocketAddressNewAbstract'.

    /Since: 2.22/
    -}
    unixSocketAddressNew ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        T.Text
        {- ^ /@path@/: the socket path -}
        -> m UnixSocketAddress
        {- ^ __Returns:__ a new 'GI.Gio.Objects.UnixSocketAddress.UnixSocketAddress' -}
    unixSocketAddressNew path = liftIO $ do
        path' <- textToCString path
        result <- g_unix_socket_address_new path'
        checkUnexpectedReturnNULL "unixSocketAddressNew" result
        result' <- (wrapObject UnixSocketAddress) result
        freeMem path'
        return result'

    #if ENABLE_OVERLOADING
    #endif

    -- method UnixSocketAddress::new_abstract
    -- method type : Constructor
    -- Args : [Arg {argCName = "path", argType = TCArray False (-1) 1 (TBasicType TInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the abstract name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path_len", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of @path, or -1", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : [Arg {argCName = "path_len", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of @path, or -1", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- returnType : Just (TInterface (Name {namespace = "Gio", name = "UnixSocketAddress"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_unix_socket_address_new_abstract" g_unix_socket_address_new_abstract ::
        Ptr Int8 ->                             -- path : TCArray False (-1) 1 (TBasicType TInt8)
        Int32 ->                                -- path_len : TBasicType TInt
        IO (Ptr UnixSocketAddress)

    {-# DEPRECATED unixSocketAddressNewAbstract ["Use 'GI.Gio.Objects.UnixSocketAddress.unixSocketAddressNewWithType'."] #-}
    {- |
    Creates a new 'GI.Gio.Enums.UnixSocketAddressTypeAbstractPadded'
    'GI.Gio.Objects.UnixSocketAddress.UnixSocketAddress' for /@path@/.
    -}
    unixSocketAddressNewAbstract ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        [Int8]
        {- ^ /@path@/: the abstract name -}
        -> m UnixSocketAddress
        {- ^ __Returns:__ a new 'GI.Gio.Objects.UnixSocketAddress.UnixSocketAddress' -}
    unixSocketAddressNewAbstract path = liftIO $ do
        let pathLen = fromIntegral $ length path
        path' <- packStorableArray path
        result <- g_unix_socket_address_new_abstract path' pathLen
        checkUnexpectedReturnNULL "unixSocketAddressNewAbstract" result
        result' <- (wrapObject UnixSocketAddress) result
        freeMem path'
        return result'

    #if ENABLE_OVERLOADING
    #endif

    -- method UnixSocketAddress::new_with_type
    -- method type : Constructor
    -- Args : [Arg {argCName = "path", argType = TCArray False (-1) 1 (TBasicType TInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the name", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path_len", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of @path, or -1", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface (Name {namespace = "Gio", name = "UnixSocketAddressType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GUnixSocketAddressType", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : [Arg {argCName = "path_len", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of @path, or -1", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- returnType : Just (TInterface (Name {namespace = "Gio", name = "UnixSocketAddress"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_unix_socket_address_new_with_type" g_unix_socket_address_new_with_type ::
        Ptr Int8 ->                             -- path : TCArray False (-1) 1 (TBasicType TInt8)
        Int32 ->                                -- path_len : TBasicType TInt
        CUInt ->                                -- type : TInterface (Name {namespace = "Gio", name = "UnixSocketAddressType"})
        IO (Ptr UnixSocketAddress)

    {- |
    Creates a new 'GI.Gio.Objects.UnixSocketAddress.UnixSocketAddress' of type /@type@/ with name /@path@/.

    If /@type@/ is 'GI.Gio.Enums.UnixSocketAddressTypePath', this is equivalent to
    calling 'GI.Gio.Objects.UnixSocketAddress.unixSocketAddressNew'.

    If /@type@/ is 'GI.Gio.Enums.UnixSocketAddressTypeAnonymous', /@path@/ and /@pathLen@/ will be
    ignored.

    If /@pathType@/ is 'GI.Gio.Enums.UnixSocketAddressTypeAbstract', then /@pathLen@/
    bytes of /@path@/ will be copied to the socket\'s path, and only those
    bytes will be considered part of the name. (If /@pathLen@/ is -1,
    then /@path@/ is assumed to be NUL-terminated.) For example, if /@path@/
    was \"test\", then calling 'GI.Gio.Objects.SocketAddress.socketAddressGetNativeSize' on the
    returned socket would return 7 (2 bytes of overhead, 1 byte for the
    abstract-socket indicator byte, and 4 bytes for the name \"test\").

    If /@pathType@/ is 'GI.Gio.Enums.UnixSocketAddressTypeAbstractPadded', then
    /@pathLen@/ bytes of /@path@/ will be copied to the socket\'s path, the
    rest of the path will be padded with 0 bytes, and the entire
    zero-padded buffer will be considered the name. (As above, if
    /@pathLen@/ is -1, then /@path@/ is assumed to be NUL-terminated.) In
    this case, 'GI.Gio.Objects.SocketAddress.socketAddressGetNativeSize' will always return
    the full size of a @struct sockaddr_un@, although
    'GI.Gio.Objects.UnixSocketAddress.unixSocketAddressGetPathLen' will still return just the
    length of /@path@/.

    'GI.Gio.Enums.UnixSocketAddressTypeAbstract' is preferred over
    'GI.Gio.Enums.UnixSocketAddressTypeAbstractPadded' for new programs. Of course,
    when connecting to a server created by another process, you must
    use the appropriate type corresponding to how that process created
    its listening socket.

    /Since: 2.26/
    -}
    unixSocketAddressNewWithType ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        [Int8]
        {- ^ /@path@/: the name -}
        -> Gio.Enums.UnixSocketAddressType
        {- ^ /@type@/: a 'GI.Gio.Enums.UnixSocketAddressType' -}
        -> m UnixSocketAddress
        {- ^ __Returns:__ a new 'GI.Gio.Objects.UnixSocketAddress.UnixSocketAddress' -}
    unixSocketAddressNewWithType path type_ = liftIO $ do
        let pathLen = fromIntegral $ length path
        path' <- packStorableArray path
        let type_' = (fromIntegral . fromEnum) type_
        result <- g_unix_socket_address_new_with_type path' pathLen type_'
        checkUnexpectedReturnNULL "unixSocketAddressNewWithType" result
        result' <- (wrapObject UnixSocketAddress) result
        freeMem path'
        return result'

    #if ENABLE_OVERLOADING
    #endif

    -- method UnixSocketAddress::get_address_type
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "address", argType = TInterface (Name {namespace = "Gio", name = "UnixSocketAddress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GInetSocketAddress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TInterface (Name {namespace = "Gio", name = "UnixSocketAddressType"}))
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_unix_socket_address_get_address_type" g_unix_socket_address_get_address_type ::
        Ptr UnixSocketAddress ->                -- address : TInterface (Name {namespace = "Gio", name = "UnixSocketAddress"})
        IO CUInt

    {- |
    Gets /@address@/\'s type.

    /Since: 2.26/
    -}
    unixSocketAddressGetAddressType ::
        (B.CallStack.HasCallStack, MonadIO m, IsUnixSocketAddress a) =>
        a
        {- ^ /@address@/: a 'GI.Gio.Objects.InetSocketAddress.InetSocketAddress' -}
        -> m Gio.Enums.UnixSocketAddressType
        {- ^ __Returns:__ a 'GI.Gio.Enums.UnixSocketAddressType' -}
    unixSocketAddressGetAddressType address = liftIO $ do
        address' <- unsafeManagedPtrCastPtr address
        result <- g_unix_socket_address_get_address_type address'
        let result' = (toEnum . fromIntegral) result
        touchManagedPtr address
        return result'

    #if ENABLE_OVERLOADING
    data UnixSocketAddressGetAddressTypeMethodInfo
    instance (signature ~ (m Gio.Enums.UnixSocketAddressType), MonadIO m, IsUnixSocketAddress a) => O.MethodInfo UnixSocketAddressGetAddressTypeMethodInfo a signature where
        overloadedMethod _ = unixSocketAddressGetAddressType

    #endif

    -- method UnixSocketAddress::get_is_abstract
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "address", argType = TInterface (Name {namespace = "Gio", name = "UnixSocketAddress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GInetSocketAddress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_unix_socket_address_get_is_abstract" g_unix_socket_address_get_is_abstract ::
        Ptr UnixSocketAddress ->                -- address : TInterface (Name {namespace = "Gio", name = "UnixSocketAddress"})
        IO CInt

    {-# DEPRECATED unixSocketAddressGetIsAbstract ["Use 'GI.Gio.Objects.UnixSocketAddress.unixSocketAddressGetAddressType'"] #-}
    {- |
    Tests if /@address@/ is abstract.

    /Since: 2.22/
    -}
    unixSocketAddressGetIsAbstract ::
        (B.CallStack.HasCallStack, MonadIO m, IsUnixSocketAddress a) =>
        a
        {- ^ /@address@/: a 'GI.Gio.Objects.InetSocketAddress.InetSocketAddress' -}
        -> m Bool
        {- ^ __Returns:__ 'True' if the address is abstract, 'False' otherwise -}
    unixSocketAddressGetIsAbstract address = liftIO $ do
        address' <- unsafeManagedPtrCastPtr address
        result <- g_unix_socket_address_get_is_abstract address'
        let result' = (/= 0) result
        touchManagedPtr address
        return result'

    #if ENABLE_OVERLOADING
    data UnixSocketAddressGetIsAbstractMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsUnixSocketAddress a) => O.MethodInfo UnixSocketAddressGetIsAbstractMethodInfo a signature where
        overloadedMethod _ = unixSocketAddressGetIsAbstract

    #endif

    -- method UnixSocketAddress::get_path
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "address", argType = TInterface (Name {namespace = "Gio", name = "UnixSocketAddress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GInetSocketAddress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TUTF8)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_unix_socket_address_get_path" g_unix_socket_address_get_path ::
        Ptr UnixSocketAddress ->                -- address : TInterface (Name {namespace = "Gio", name = "UnixSocketAddress"})
        IO CString

    {- |
    Gets /@address@/\'s path, or for abstract sockets the \"name\".

    Guaranteed to be zero-terminated, but an abstract socket
    may contain embedded zeros, and thus you should use
    'GI.Gio.Objects.UnixSocketAddress.unixSocketAddressGetPathLen' to get the true length
    of this string.

    /Since: 2.22/
    -}
    unixSocketAddressGetPath ::
        (B.CallStack.HasCallStack, MonadIO m, IsUnixSocketAddress a) =>
        a
        {- ^ /@address@/: a 'GI.Gio.Objects.InetSocketAddress.InetSocketAddress' -}
        -> m T.Text
        {- ^ __Returns:__ the path for /@address@/ -}
    unixSocketAddressGetPath address = liftIO $ do
        address' <- unsafeManagedPtrCastPtr address
        result <- g_unix_socket_address_get_path address'
        checkUnexpectedReturnNULL "unixSocketAddressGetPath" result
        result' <- cstringToText result
        touchManagedPtr address
        return result'

    #if ENABLE_OVERLOADING
    data UnixSocketAddressGetPathMethodInfo
    instance (signature ~ (m T.Text), MonadIO m, IsUnixSocketAddress a) => O.MethodInfo UnixSocketAddressGetPathMethodInfo a signature where
        overloadedMethod _ = unixSocketAddressGetPath

    #endif

    -- method UnixSocketAddress::get_path_len
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "address", argType = TInterface (Name {namespace = "Gio", name = "UnixSocketAddress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GInetSocketAddress", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Just (TBasicType TUInt64)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_unix_socket_address_get_path_len" g_unix_socket_address_get_path_len ::
        Ptr UnixSocketAddress ->                -- address : TInterface (Name {namespace = "Gio", name = "UnixSocketAddress"})
        IO Word64

    {- |
    Gets the length of /@address@/\'s path.

    For details, see 'GI.Gio.Objects.UnixSocketAddress.unixSocketAddressGetPath'.

    /Since: 2.22/
    -}
    unixSocketAddressGetPathLen ::
        (B.CallStack.HasCallStack, MonadIO m, IsUnixSocketAddress a) =>
        a
        {- ^ /@address@/: a 'GI.Gio.Objects.InetSocketAddress.InetSocketAddress' -}
        -> m Word64
        {- ^ __Returns:__ the length of the path -}
    unixSocketAddressGetPathLen address = liftIO $ do
        address' <- unsafeManagedPtrCastPtr address
        result <- g_unix_socket_address_get_path_len address'
        touchManagedPtr address
        return result

    #if ENABLE_OVERLOADING
    data UnixSocketAddressGetPathLenMethodInfo
    instance (signature ~ (m Word64), MonadIO m, IsUnixSocketAddress a) => O.MethodInfo UnixSocketAddressGetPathLenMethodInfo a signature where
        overloadedMethod _ = unixSocketAddressGetPathLen

    #endif

    -- method UnixSocketAddress::abstract_names_supported
    -- method type : MemberFunction
    -- Args : []
    -- Lengths : []
    -- returnType : Just (TBasicType TBoolean)
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_unix_socket_address_abstract_names_supported" g_unix_socket_address_abstract_names_supported ::
        IO CInt

    {- |
    Checks if abstract UNIX domain socket names are supported.

    /Since: 2.22/
    -}
    unixSocketAddressAbstractNamesSupported ::
        (B.CallStack.HasCallStack, MonadIO m) =>
        m Bool
        {- ^ __Returns:__ 'True' if supported, 'False' otherwise -}
    unixSocketAddressAbstractNamesSupported  = liftIO $ do
        result <- g_unix_socket_address_abstract_names_supported
        let result' = (/= 0) result
        return result'

    #if ENABLE_OVERLOADING
    #endif