Current File : //proc/self/root/kunden/usr/share/emacs/27.2/lisp/net/soap-client.elc

;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(byte-code "\300\301!\210\300\302!\210\300\303!\210\300\304!\210\300\305!\210\300\306!\210\300\307!\210\300\310!\210\300\311!\210\300\312!\210\300\313!\207" [require cl-lib xml xsd-regexp rng-xsd rng-dt warnings url url-http url-util url-vars mm-decode] 2)
#@101 Display a warning MESSAGE with ARGS, using the `soap-client' warning type.

(fn MESSAGE &rest ARGS)
(defalias 'soap-warning #[385 "\300\301\302\303#\304#\207" [display-warning soap-client apply format :warning] 8 (#$ . 666)])
(byte-code "\300\301\302\303#\210\304\305\306\307\310\311\312\313&\207" [put soap-warning byte-optimizer byte-compile-inline-expand custom-declare-group soap-client nil "Access SOAP web services from Emacs." :version "24.1" :group tools] 8)
#@56 A list of well known xml namespaces and their aliases.
(defconst soap-well-known-xmlns '(("apachesoap" . "http://xml.apache.org/xml-soap") ("soapenc" . "http://schemas.xmlsoap.org/soap/encoding/") ("wsdl" . "http://schemas.xmlsoap.org/wsdl/") ("wsdlsoap" . "http://schemas.xmlsoap.org/wsdl/soap/") ("xsd" . "http://www.w3.org/2001/XMLSchema") ("xsi" . "http://www.w3.org/2001/XMLSchema-instance") ("wsa" . "http://www.w3.org/2005/08/addressing") ("wsaw" . "http://www.w3.org/2006/05/addressing/wsdl") ("soap" . "http://schemas.xmlsoap.org/soap/envelope/") ("soap12" . "http://schemas.xmlsoap.org/wsdl/soap12/") ("http" . "http://schemas.xmlsoap.org/wsdl/http/") ("mime" . "http://schemas.xmlsoap.org/wsdl/mime/") ("xml" . "http://www.w3.org/XML/1998/namespace")) (#$ . 1142))
#@113 A list of local namespace aliases.
This is a dynamically bound variable, controlled by
`soap-with-local-xmlns'.
(defvar soap-local-xmlns '(("xml" . "http://www.w3.org/XML/1998/namespace")) (#$ . 1925))
#@151 The default XML namespaces.
Names in this namespace will be unqualified.  This is a
dynamically bound variable, controlled by
`soap-with-local-xmlns'
(defvar soap-default-xmlns nil (#$ . 2134))
#@215 The target XML namespace.
New XSD elements will be defined in this namespace, unless they
are fully qualified for a different namespace.  This is a
dynamically bound variable, controlled by
`soap-with-local-xmlns'
(defvar soap-target-xmlns nil (#$ . 2335))
#@103 The current WSDL document used when decoding the SOAP response.
This is a dynamically bound variable.
(defvar soap-current-wsdl nil (#$ . 2599))
#@288 Return local variant of WELL-KNOWN-NAME.
This is done by looking up the namespace in the
`soap-well-known-xmlns' table and resolving the namespace to
the local name based on the current local translation table
`soap-local-xmlns'.  See also `soap-with-local-xmlns'.

(fn WELL-KNOWN-NAME)
(defalias 'soap-wk2l #[257 "\2119\203\303
!\202\f\211\304\305\"\203T\306\307\"\306\310\"\311\"A\211	\232\20359\2031\312!\202M
\202M\313
\n\"@\211\314Q9\203J\312
!\202K\211\266\202\262
\266\202\202U
\207" [soap-well-known-xmlns soap-default-xmlns soap-local-xmlns symbol-name string-match "^\\(.*\\):\\(.*\\)$" match-string 1 2 assoc intern rassoc ":"] 9 (#$ . 2751)])
#@277 Convert LOCAL-NAME into a well known name.
The namespace of LOCAL-NAME is looked up in the
`soap-well-known-xmlns' table and a well known namespace tag is
used in the name.

nil is returned if there is no well-known namespace for the
namespace of LOCAL-NAME.

(fn LOCAL-NAME)
(defalias 'soap-l2wk #[257 "\2119\203\303
!\202\f\211\304\211\305\306\"\2035\307\310\"\262
\307\311\"\312
\"A\262\2041\313\314#\210\210\202;\262
	\262
\203_\315\n\"@\211\205Z\211\316Q9\203W\317
!\202X\211\262
\262
\202`\211\207" [soap-local-xmlns soap-default-xmlns soap-well-known-xmlns symbol-name nil string-match "^\\(.*\\):\\(.*\\)$" match-string 2 1 assoc error "Soap-l2wk(%s): no namespace for alias %s" rassoc ":" intern] 9 (#$ . 3434)])
#@598 Convert LOCAL-NAME into a fully qualified name.
A fully qualified name is a cons of the namespace name and the
name of the element itself.  For example "xsd:string" is
converted to ("http://www.w3.org/2001/XMLSchema" . "string").

The USE-TNS argument specifies what to do when LOCAL-NAME has no
namespace tag.  If USE-TNS is non-nil, the `soap-target-xmlns'
will be used as the element's namespace, otherwise
`soap-default-xmlns' will be used.

This is needed because different parts of a WSDL document can use
different namespace aliases for the same element.

(fn LOCAL-NAME &optional USE-TNS)
(defalias 'soap-l2fq #[513 "
9\203\303!\202\f
\304\305\"\2037\306\307\"\306\310\"\311\"A\211\203*\211B\2020\312\313#\262
\266\202\202B
\203?	\202@\n
B\207" [soap-local-xmlns soap-target-xmlns soap-default-xmlns symbol-name string-match "^\\(.*\\):\\(.*\\)$" match-string 1 2 assoc error "Soap-l2fq(%s): unknown alias %s"] 10 (#$ . 4188)])
#@131 Return t if NAME is a valid name for XMLSchema types.
A valid name is either a string or a cons of (NAMESPACE . NAME).

(fn NAME)
(defalias 'soap-name-p #[257 "\211;\206\211:\205\211@;\205\211A;\207" [] 2 (#$ . 5150)])
#@100 Return a namespace alias table for NODE by extending XMLNS-TABLE.

(fn NODE &optional XMLNS-TABLE)
(defalias 'soap-extract-xmlns #[513 "\300\211\211\211A@\262
\211\203H\211@\301
@!
A
\302\230\203!\211\262\202?
\303\230\203-\211\262\202?\304\305\"\203?\306\307\"
BB\262\266
A\266\202\202	\210\310\311\"\211\203r
\203r

A\232\204~\312\211@\262
C\313\314\315\316#\317#\266\202~\211\203~
\204~\211A\262\210

\320\"E\207" [nil symbol-name "targetNamespace" "xmlns" string-match "^xmlns:\\(.*\\)$" match-string 1 assoc "tns" "soap-extract-xmlns(%s): tns alias and targetNamespace mismatch" display-warning soap-client apply format :warning append] 14 (#$ . 5382)])
#@79 Install a local alias table from NODE and execute BODY.

(fn NODE &rest BODY)
(defalias 'soap-with-local-xmlns '(macro . #[385 "\300\301!\302
\303\304BBDC\302\305\306\307\310E\311BBD\312\306\307\313E\314BBD\315\307\316EDEBBE\207" [make-symbol "xmlns" let soap-extract-xmlns (soap-local-xmlns) soap-default-xmlns or nth 0 (soap-default-xmlns) soap-target-xmlns 1 (soap-target-xmlns) soap-local-xmlns 2] 12 (#$ . 6079)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put soap-with-local-xmlns edebug-form-spec (form &rest form) function-put lisp-indent-function 1] 4)
#@110 Return the target namespace of NODE.
This is the namespace in which new elements will be defined.

(fn NODE)
(defalias 'soap-get-target-namespace #[257 "\302
\303\"\206\304\305\"A\206	\207" [soap-local-xmlns soap-target-xmlns xml-get-attribute-or-nil targetNamespace assoc "tns"] 4 (#$ . 6676)])
#@148 Return the children of NODE named CHILD-NAME.
This is the same as `xml-get-children', but CHILD-NAME can have
namespace tag.

(fn NODE CHILD-NAME)
(defalias 'soap-xml-get-children1 #[514 "\303\211AA\262
\211\203N\211@\211:\203G\304
\"\211@\206	
A@\206#\n\3058\30618\307\211@\262
!0\202:\210\303+=\262
\203G\211B\262
A\266\202\202\210\211\237\207" [soap-local-xmlns soap-default-xmlns soap-target-xmlns nil soap-extract-xmlns 2 (error) soap-l2wk] 10 (#$ . 6984)])
#@78 Return the first child of NODE whose name is a member of SET.

(fn NODE SET)
(defalias 'soap-xml-node-find-matching-child #[514 "\30020
\211AA\262
\211\205-\211@\211:\203&\301
\211@\262
!>\203&\302\300\"\210
A\266\202\202\n\262
0\207" [found soap-l2wk throw] 7 (#$ . 7473)])
#@178 Return the NODE's ATTRIBUTE, or nil if it does not exist.
This is the same as `xml-get-attribute-or-nil', but ATTRIBUTE can
be tagged with a namespace tag.

(fn NODE ATTRIBUTE)
(defalias 'soap-xml-get-attribute-or-nil1 #[514 "\3032M\304\"\211@\206	
A@\206\n\3058\211A@\262
\211\205G\211@\30613\307
@!0\2025\210\310=\203@\311\303A\"\210
A\266\202\202!\262
+\262
0\207" [soap-local-xmlns soap-default-xmlns soap-target-xmlns found soap-extract-xmlns 2 (error) soap-l2wk nil throw] 8 (#$ . 7762)])
#@71 compiler-macro for inlining `soap-element-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-element-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-element-p (and (memq (type-of cl-x) cl-struct-soap-element-tags) t)) nil] 9 (#$ . 8282)])
(put 'soap-element-p 'compiler-macro 'soap-element-p--cmacro)
#@13 

(fn CL-X)
(defalias 'soap-element-p #[257 "\301
!>\205	\302\207" [cl-struct-soap-element-tags type-of t] 3 (#$ . 8628)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put soap-element-p side-effect-free error-free put soap-element cl-deftype-satisfies] 5)
#@74 compiler-macro for inlining `soap-element-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-element-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-element-name (progn (or (soap-element-p cl-x) (signal 'wrong-type-argument (list 'soap-element cl-x))) (aref cl-x 1))) nil] 9 (#$ . 8910)])
(put 'soap-element-name 'compiler-macro 'soap-element-name--cmacro)
#@62 Access slot "name" of `soap-element' struct CL-X.

(fn CL-X)
(defalias 'soap-element-name #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-element-tags type-of signal wrong-type-argument soap-element 1] 5 (#$ . 9318)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-element-name side-effect-free t] 4)
#@83 compiler-macro for inlining `soap-element-namespace-tag'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-element-namespace-tag--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-element-namespace-tag (progn (or (soap-element-p cl-x) (signal 'wrong-type-argument (list 'soap-element cl-x))) (aref cl-x 2))) nil] 9 (#$ . 9660)])
(put 'soap-element-namespace-tag 'compiler-macro 'soap-element-namespace-tag--cmacro)
#@71 Access slot "namespace-tag" of `soap-element' struct CL-X.

(fn CL-X)
(defalias 'soap-element-namespace-tag #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-element-tags type-of signal wrong-type-argument soap-element 2] 5 (#$ . 10113)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put soap-element-namespace-tag side-effect-free t defalias copy-soap-element copy-sequence] 4)
#@99 compiler-macro for inlining `make-soap-element'.

(fn CL-WHOLE &cl-quote &key NAME NAMESPACE-TAG)
(defalias 'make-soap-element--cmacro #[385 "\300
\301\"A@\300\302\"A@\211\2037\211@\303>\203 \211AA\262
\202
\304>A@\203.\305\262
\202
\306\307@\"\210\202
\210\310\311\312\305\305&\207" [plist-member :name :namespace-tag (:name :namespace-tag :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag)" cl--defsubst-expand (name namespace-tag) (cl-block make-soap-element (record 'soap-element name namespace-tag))] 12 (#$ . 10534)])
(put 'make-soap-element 'compiler-macro 'make-soap-element--cmacro)
#@79 Constructor for objects of type `soap-element'.

(fn &key NAME NAMESPACE-TAG)
(defalias 'make-soap-element #[128 "\300
\301\"A@\300\302\"A@\211\2037\211@\303>\203 \211AA\262
\202
\304>A@\203.\305\262
\202
\306\307@\"\210\202
\210\310\311#\207" [plist-member :name :namespace-tag (:name :namespace-tag :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag)" record soap-element] 7 (#$ . 11200)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-soap-element side-effect-free t cl-struct-define soap-element nil cl-structure-object record ((cl-tag-slot) (name) (namespace-tag)) cl-struct-soap-element-tags] 11)
#@132 Return a fully qualified name for ELEMENT.
A fq name is the concatenation of the namespace tag and the
element name.

(fn ELEMENT)
(defalias 'soap-element-fq-name #[257 "\301
!>\204\302\303\304D\"\210\211\305H\203<\301
!>\204$\302\303\304D\"\210\211\305H\306\301!>\2047\302\303\304D\"\210\307HQ\207\301
!>\204K\302\303\304D\"\210\211\307H\203d\301
!>\204`\302\303\304D\"\210\211\307H\207\310\207" [cl-struct-soap-element-tags type-of signal wrong-type-argument soap-element 2 ":" 1 "*unnamed*"] 7 (#$ . 11922)])
#@78 compiler-macro for inlining `soap-namespace-link-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-namespace-link-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-namespace-link-p (and (memq (type-of cl-x) cl-struct-soap-namespace-link-tags) t)) nil] 9 (#$ . 12460)])
(put 'soap-namespace-link-p 'compiler-macro 'soap-namespace-link-p--cmacro)
#@13 

(fn CL-X)
(defalias 'soap-namespace-link-p #[257 "\301
!>\205	\302\207" [cl-struct-soap-namespace-link-tags type-of t] 3 (#$ . 12849)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put soap-namespace-link-p side-effect-free error-free put soap-namespace-link cl-deftype-satisfies] 5)
#@81 compiler-macro for inlining `soap-namespace-link-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-namespace-link-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-namespace-link-name (progn (or (soap-namespace-link-p cl-x) (signal 'wrong-type-argument (list 'soap-namespace-link cl-x))) (aref cl-x 1))) nil] 9 (#$ . 13160)])
(put 'soap-namespace-link-name 'compiler-macro 'soap-namespace-link-name--cmacro)
#@69 Access slot "name" of `soap-namespace-link' struct CL-X.

(fn CL-X)
(defalias 'soap-namespace-link-name #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-namespace-link-tags type-of signal wrong-type-argument soap-namespace-link 1] 5 (#$ . 13618)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-namespace-link-name side-effect-free t] 4)
#@90 compiler-macro for inlining `soap-namespace-link-namespace-tag'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-namespace-link-namespace-tag--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-namespace-link-namespace-tag (progn (or (soap-namespace-link-p cl-x) (signal 'wrong-type-argument (list 'soap-namespace-link cl-x))) (aref cl-x 2))) nil] 9 (#$ . 13996)])
(put 'soap-namespace-link-namespace-tag 'compiler-macro 'soap-namespace-link-namespace-tag--cmacro)
#@78 Access slot "namespace-tag" of `soap-namespace-link' struct CL-X.

(fn CL-X)
(defalias 'soap-namespace-link-namespace-tag #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-namespace-link-tags type-of signal wrong-type-argument soap-namespace-link 2] 5 (#$ . 14499)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-namespace-link-namespace-tag side-effect-free t] 4)
#@83 compiler-macro for inlining `soap-namespace-link-target'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-namespace-link-target--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-namespace-link-target (progn (or (soap-namespace-link-p cl-x) (signal 'wrong-type-argument (list 'soap-namespace-link cl-x))) (aref cl-x 3))) nil] 9 (#$ . 14904)])
(put 'soap-namespace-link-target 'compiler-macro 'soap-namespace-link-target--cmacro)
#@71 Access slot "target" of `soap-namespace-link' struct CL-X.

(fn CL-X)
(defalias 'soap-namespace-link-target #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-namespace-link-tags type-of signal wrong-type-argument soap-namespace-link 3] 5 (#$ . 15372)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put soap-namespace-link-target side-effect-free t defalias copy-soap-namespace-link copy-sequence] 4)
#@113 compiler-macro for inlining `make-soap-namespace-link'.

(fn CL-WHOLE &cl-quote &key NAME NAMESPACE-TAG TARGET)
(defalias 'make-soap-namespace-link--cmacro #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\211\203=\211@\304>\203&\211AA\262
\202\305>A@\2034\306\262
\202\307\310@\"\210\202\210\311\312\313\306\306&\207" [plist-member :name :namespace-tag :target (:name :namespace-tag :target :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :target)" cl--defsubst-expand (name namespace-tag target) (cl-block make-soap-namespace-link (record 'soap-namespace-link name namespace-tag target))] 14 (#$ . 15815)])
(put 'make-soap-namespace-link 'compiler-macro 'make-soap-namespace-link--cmacro)
#@93 Constructor for objects of type `soap-namespace-link'.

(fn &key NAME NAMESPACE-TAG TARGET)
(defalias 'make-soap-namespace-link #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\211\203=\211@\304>\203&\211AA\262
\202\305>A@\2034\306\262
\202\307\310@\"\210\202\210\311\312$\207" [plist-member :name :namespace-tag :target (:name :namespace-tag :target :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :target)" record soap-namespace-link] 9 (#$ . 16583)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-soap-namespace-link side-effect-free t cl-struct-define soap-namespace-link nil soap-element record ((cl-tag-slot) (name nil) (namespace-tag nil) (target)) cl-struct-soap-namespace-link-tags] 11)
#@73 compiler-macro for inlining `soap-namespace-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-namespace-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-namespace-p (and (memq (type-of cl-x) cl-struct-soap-namespace-tags) t)) nil] 9 (#$ . 17401)])
(put 'soap-namespace-p 'compiler-macro 'soap-namespace-p--cmacro)
#@13 

(fn CL-X)
(defalias 'soap-namespace-p #[257 "\301
!>\205	\302\207" [cl-struct-soap-namespace-tags type-of t] 3 (#$ . 17760)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put soap-namespace-p side-effect-free error-free put soap-namespace cl-deftype-satisfies] 5)
#@76 compiler-macro for inlining `soap-namespace-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-namespace-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-namespace-name (progn (or (soap-namespace-p cl-x) (signal 'wrong-type-argument (list 'soap-namespace cl-x))) (aref cl-x 1))) nil] 9 (#$ . 18051)])
(put 'soap-namespace-name 'compiler-macro 'soap-namespace-name--cmacro)
#@64 Access slot "name" of `soap-namespace' struct CL-X.

(fn CL-X)
(defalias 'soap-namespace-name #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-namespace-tags type-of signal wrong-type-argument soap-namespace 1] 5 (#$ . 18474)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put soap-namespace-name side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" soap-namespace-name] 5 "\n\n(fn CL-DO CL-X)"]] 5)
#@80 compiler-macro for inlining `soap-namespace-elements'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-namespace-elements--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-namespace-elements (progn (or (soap-namespace-p cl-x) (signal 'wrong-type-argument (list 'soap-namespace cl-x))) (aref cl-x 2))) nil] 9 (#$ . 18961)])
(put 'soap-namespace-elements 'compiler-macro 'soap-namespace-elements--cmacro)
#@68 Access slot "elements" of `soap-namespace' struct CL-X.

(fn CL-X)
(defalias 'soap-namespace-elements #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-namespace-tags type-of signal wrong-type-argument soap-namespace 2] 5 (#$ . 19404)])
(byte-code "\300\301\302\303#\300\301\304\305#\306\307\310\"\207" [function-put soap-namespace-elements side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" soap-namespace-elements] 5 "\n\n(fn CL-DO CL-X)"] defalias copy-soap-namespace copy-sequence] 5)
#@96 compiler-macro for inlining `make-soap-namespace'.

(fn CL-WHOLE &cl-quote &key NAME ELEMENTS)
(defalias 'make-soap-namespace--cmacro #[385 "\300
\301\"A@\300\302\"\206\303A@\211\203;\211@\304>\203$\211AA\262
\202\305>A@\2032\306\262
\202\307\310@\"\210\202\210\311\312\313\306\306&\207" [plist-member :name :elements (nil (make-hash-table :test 'equal)) (:name :elements :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :elements)" cl--defsubst-expand (name elements) (cl-block make-soap-namespace (record 'soap-namespace name elements))] 12 (#$ . 19960)])
(put 'make-soap-namespace 'compiler-macro 'make-soap-namespace--cmacro)
#@76 Constructor for objects of type `soap-namespace'.

(fn &key NAME ELEMENTS)
(defalias 'make-soap-namespace #[128 "\300
\301\"A@\300\302\"\206\303\304\305\306\"DA@\211\203@\211@\307>\203)\211AA\262
\202\310>A@\2037\303\262
\202\311\312@\"\210\202\210\313\314#\207" [plist-member :name :elements nil make-hash-table :test equal (:name :elements :allow-other-keys) :allow-other-keys error "Keyword argument %s not one of (:name :elements)" record soap-namespace] 7 (#$ . 20655)])
(cl-struct-define 'soap-namespace nil 'cl-structure-object 'record nil '((cl-tag-slot) (name nil :read-only t) (elements (make-hash-table :test 'equal) :read-only t)) 'cl-struct-soap-namespace-tags 'soap-namespace t)
#@201 Store ELEMENT in NS.
Multiple elements with the same name can be stored in a
namespace.  When retrieving the element you can specify a
discriminant predicate to `soap-namespace-get'.

(fn ELEMENT NS)
(defalias 'soap-namespace-put #[514 "\302!>\204\303\304\305D\"\210
\306H\211\302!	>\204\"\303\304\307D\"\210\310H\311\312\"B#\266\202\207" [cl-struct-soap-element-tags cl-struct-soap-namespace-tags type-of signal wrong-type-argument soap-element 1 soap-namespace 2 puthash gethash] 11 (#$ . 21372)])
#@248 Store a link from NAME to TARGET in NS.
TARGET can be either a SOAP-ELEMENT or a string denoting an
element name into another namespace.

If NAME is nil, an element with the same name as TARGET will be
added to the namespace.

(fn NAME TARGET NS)
(defalias 'soap-namespace-put-link #[771 "\203\n\302\232\203M\303!>\203)\303!>\204!\304\305\306D\"\210
\307H\262\202M
:\2035
A\262\202M
;\203M\310\311\"\203J\312\313\"\262\202M
\262\203W\302\232\203^\314\315\316\317\211$\210\320\321\317$\303!	>\204t\304\305\322D\"\210\313H\323\324\"B#\207" [cl-struct-soap-element-tags cl-struct-soap-namespace-tags #1="" type-of signal wrong-type-argument soap-element 1 string-match "^\\(.*\\):\\(.*\\)$" match-string 2 cl--assertion-failed (and name (not (equal name #1#))) "Cannot determine name for namespace link" nil record soap-namespace-link soap-namespace puthash gethash] 12 (#$ . 21894)])
#@304 Retrieve an element with NAME from the namespace NS.
If multiple elements with the same name exist,
DISCRIMINANT-PREDICATE is used to pick one of them.  This allows
storing elements of different types (like a message type and a
binding) but the same name.

(fn NAME NS &optional DISCRIMINANT-PREDICATE)
(defalias 'soap-namespace-get #[770 ";\204	\301\302!\210\303\304!>\204\305\306\307D\"\210\310H\"
\203F\3112a\211\211\205@\211@
!\2039\312\311\"\210
A\266\202\202(\262
0\202a\211G\313U\203R\211@\202a\211G\313V\203`\314\315\"\202a\316\207" [cl-struct-soap-namespace-tags cl--assertion-failed (stringp name) gethash type-of signal wrong-type-argument soap-namespace 2 found throw 1 error "Soap-namespace-get(%s): multiple elements, discriminant needed" nil] 9 (#$ . 22822)])
#@71 compiler-macro for inlining `soap-xs-type-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-type-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-type-p (and (memq (type-of cl-x) cl-struct-soap-xs-type-tags) t)) nil] 9 (#$ . 23626)])
(put 'soap-xs-type-p 'compiler-macro 'soap-xs-type-p--cmacro)
#@13 

(fn CL-X)
(defalias 'soap-xs-type-p #[257 "\301
!>\205	\302\207" [cl-struct-soap-xs-type-tags type-of t] 3 (#$ . 23973)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put soap-xs-type-p side-effect-free error-free put soap-xs-type cl-deftype-satisfies] 5)
#@74 compiler-macro for inlining `soap-xs-type-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-type-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-type-name (progn (or (soap-xs-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-type cl-x))) (aref cl-x 1))) nil] 9 (#$ . 24256)])
(put 'soap-xs-type-name 'compiler-macro 'soap-xs-type-name--cmacro)
#@62 Access slot "name" of `soap-xs-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-type-name #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-type-tags type-of signal wrong-type-argument soap-xs-type 1] 5 (#$ . 24665)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-type-name side-effect-free t] 4)
#@83 compiler-macro for inlining `soap-xs-type-namespace-tag'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-type-namespace-tag--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-type-namespace-tag (progn (or (soap-xs-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-type cl-x))) (aref cl-x 2))) nil] 9 (#$ . 25008)])
(put 'soap-xs-type-namespace-tag 'compiler-macro 'soap-xs-type-namespace-tag--cmacro)
#@71 Access slot "namespace-tag" of `soap-xs-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-type-namespace-tag #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-type-tags type-of signal wrong-type-argument soap-xs-type 2] 5 (#$ . 25462)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-type-namespace-tag side-effect-free t] 4)
#@72 compiler-macro for inlining `soap-xs-type-id'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-type-id--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-type-id (progn (or (soap-xs-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-type cl-x))) (aref cl-x 3))) nil] 9 (#$ . 25832)])
(put 'soap-xs-type-id 'compiler-macro 'soap-xs-type-id--cmacro)
#@60 Access slot "id" of `soap-xs-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-type-id #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-type-tags type-of signal wrong-type-argument soap-xs-type 3] 5 (#$ . 26231)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-type-id side-effect-free t] 4)
#@80 compiler-macro for inlining `soap-xs-type-attributes'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-type-attributes--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-type-attributes (progn (or (soap-xs-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-type cl-x))) (aref cl-x 4))) nil] 9 (#$ . 26568)])
(put 'soap-xs-type-attributes 'compiler-macro 'soap-xs-type-attributes--cmacro)
#@68 Access slot "attributes" of `soap-xs-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-type-attributes #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-type-tags type-of signal wrong-type-argument soap-xs-type 4] 5 (#$ . 27007)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-type-attributes side-effect-free t] 4)
#@86 compiler-macro for inlining `soap-xs-type-attribute-groups'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-type-attribute-groups--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-type-attribute-groups (progn (or (soap-xs-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-type cl-x))) (aref cl-x 5))) nil] 9 (#$ . 27368)])
(put 'soap-xs-type-attribute-groups 'compiler-macro 'soap-xs-type-attribute-groups--cmacro)
#@74 Access slot "attribute-groups" of `soap-xs-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-type-attribute-groups #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-type-tags type-of signal wrong-type-argument soap-xs-type 5] 5 (#$ . 27837)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put soap-xs-type-attribute-groups side-effect-free t defalias copy-soap-xs-type copy-sequence] 4)
#@130 compiler-macro for inlining `make-soap-xs-type'.

(fn CL-WHOLE &cl-quote &key NAME NAMESPACE-TAG ID ATTRIBUTES ATTRIBUTE-GROUPS)
(defalias 'make-soap-xs-type--cmacro #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\211\203J\211@\306>\2032\211AA\262
\202\307>A@\203A\310\262
\202\311\312@\"\210\202\210\313\314\315\310\n\310\n\n\n\n\n&\n\207" [plist-member :name :namespace-tag :id :attributes :attribute-groups (:name :namespace-tag :id :attributes :attribute-groups :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :id :attributes :attribute-groups)" cl--defsubst-expand (name namespace-tag id attributes attribute-groups) (cl-block make-soap-xs-type (record 'soap-xs-type name namespace-tag id attributes attribute-groups))] 18 (#$ . 28268)])
(put 'make-soap-xs-type 'compiler-macro 'make-soap-xs-type--cmacro)
#@110 Constructor for objects of type `soap-xs-type'.

(fn &key NAME NAMESPACE-TAG ID ATTRIBUTES ATTRIBUTE-GROUPS)
(defalias 'make-soap-xs-type #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\211\203J\211@\306>\2032\211AA\262
\202\307>A@\203A\310\262
\202\311\312@\"\210\202\210\313\314&\207" [plist-member :name :namespace-tag :id :attributes :attribute-groups (:name :namespace-tag :id :attributes :attribute-groups :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :id :attributes :attribute-groups)" record soap-xs-type] 13 (#$ . 29183)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-soap-xs-type side-effect-free t cl-struct-define soap-xs-type nil soap-element record ((cl-tag-slot) (name nil) (namespace-tag nil) (id) (attributes) (attribute-groups)) cl-struct-soap-xs-type-tags] 11)
#@77 compiler-macro for inlining `soap-xs-basic-type-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-basic-type-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-basic-type-p (and (memq (type-of cl-x) cl-struct-soap-xs-basic-type-tags) t)) nil] 9 (#$ . 30125)])
(put 'soap-xs-basic-type-p 'compiler-macro 'soap-xs-basic-type-p--cmacro)
#@13 

(fn CL-X)
(defalias 'soap-xs-basic-type-p #[257 "\301
!>\205	\302\207" [cl-struct-soap-xs-basic-type-tags type-of t] 3 (#$ . 30508)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put soap-xs-basic-type-p side-effect-free error-free put soap-xs-basic-type cl-deftype-satisfies] 5)
#@80 compiler-macro for inlining `soap-xs-basic-type-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-basic-type-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-basic-type-name (progn (or (soap-xs-basic-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-basic-type cl-x))) (aref cl-x 1))) nil] 9 (#$ . 30815)])
(put 'soap-xs-basic-type-name 'compiler-macro 'soap-xs-basic-type-name--cmacro)
#@68 Access slot "name" of `soap-xs-basic-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-basic-type-name #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-basic-type-tags type-of signal wrong-type-argument soap-xs-basic-type 1] 5 (#$ . 31266)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-basic-type-name side-effect-free t] 4)
#@89 compiler-macro for inlining `soap-xs-basic-type-namespace-tag'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-basic-type-namespace-tag--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-basic-type-namespace-tag (progn (or (soap-xs-basic-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-basic-type cl-x))) (aref cl-x 2))) nil] 9 (#$ . 31639)])
(put 'soap-xs-basic-type-namespace-tag 'compiler-macro 'soap-xs-basic-type-namespace-tag--cmacro)
#@77 Access slot "namespace-tag" of `soap-xs-basic-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-basic-type-namespace-tag #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-basic-type-tags type-of signal wrong-type-argument soap-xs-basic-type 2] 5 (#$ . 32135)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-basic-type-namespace-tag side-effect-free t] 4)
#@78 compiler-macro for inlining `soap-xs-basic-type-id'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-basic-type-id--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-basic-type-id (progn (or (soap-xs-basic-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-basic-type cl-x))) (aref cl-x 3))) nil] 9 (#$ . 32535)])
(put 'soap-xs-basic-type-id 'compiler-macro 'soap-xs-basic-type-id--cmacro)
#@66 Access slot "id" of `soap-xs-basic-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-basic-type-id #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-basic-type-tags type-of signal wrong-type-argument soap-xs-basic-type 3] 5 (#$ . 32976)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-basic-type-id side-effect-free t] 4)
#@86 compiler-macro for inlining `soap-xs-basic-type-attributes'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-basic-type-attributes--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-basic-type-attributes (progn (or (soap-xs-basic-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-basic-type cl-x))) (aref cl-x 4))) nil] 9 (#$ . 33343)])
(put 'soap-xs-basic-type-attributes 'compiler-macro 'soap-xs-basic-type-attributes--cmacro)
#@74 Access slot "attributes" of `soap-xs-basic-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-basic-type-attributes #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-basic-type-tags type-of signal wrong-type-argument soap-xs-basic-type 4] 5 (#$ . 33824)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-basic-type-attributes side-effect-free t] 4)
#@92 compiler-macro for inlining `soap-xs-basic-type-attribute-groups'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-basic-type-attribute-groups--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-basic-type-attribute-groups (progn (or (soap-xs-basic-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-basic-type cl-x))) (aref cl-x 5))) nil] 9 (#$ . 34215)])
(put 'soap-xs-basic-type-attribute-groups 'compiler-macro 'soap-xs-basic-type-attribute-groups--cmacro)
#@80 Access slot "attribute-groups" of `soap-xs-basic-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-basic-type-attribute-groups #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-basic-type-tags type-of signal wrong-type-argument soap-xs-basic-type 5] 5 (#$ . 34726)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-basic-type-attribute-groups side-effect-free t] 4)
#@80 compiler-macro for inlining `soap-xs-basic-type-kind'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-basic-type-kind--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-basic-type-kind (progn (or (soap-xs-basic-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-basic-type cl-x))) (aref cl-x 6))) nil] 9 (#$ . 35135)])
(put 'soap-xs-basic-type-kind 'compiler-macro 'soap-xs-basic-type-kind--cmacro)
#@68 Access slot "kind" of `soap-xs-basic-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-basic-type-kind #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-basic-type-tags type-of signal wrong-type-argument soap-xs-basic-type 6] 5 (#$ . 35586)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put soap-xs-basic-type-kind side-effect-free t defalias copy-soap-xs-basic-type copy-sequence] 4)
#@141 compiler-macro for inlining `make-soap-xs-basic-type'.

(fn CL-WHOLE &cl-quote &key NAME NAMESPACE-TAG ID ATTRIBUTES ATTRIBUTE-GROUPS KIND)
(defalias 'make-soap-xs-basic-type--cmacro #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\211\203R\211@\307>\203:\211AA\262
\202'\310>A@\203I\311\262
\202'\312\313@\"\210\202'\210\314\315\316\311\311&\207" [plist-member :name :namespace-tag :id :attributes :attribute-groups :kind (:name :namespace-tag :id :attributes :attribute-groups :kind :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :id :attributes :attribute-groups :kind)" cl--defsubst-expand (name namespace-tag id attributes attribute-groups kind) (cl-block make-soap-xs-basic-type (record 'soap-xs-basic-type name namespace-tag id attributes attribute-groups kind))] 20 (#$ . 36017)])
(put 'make-soap-xs-basic-type 'compiler-macro 'make-soap-xs-basic-type--cmacro)
#@121 Constructor for objects of type `soap-xs-basic-type'.

(fn &key NAME NAMESPACE-TAG ID ATTRIBUTES ATTRIBUTE-GROUPS KIND)
(defalias 'make-soap-xs-basic-type #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\211\203R\211@\307>\203:\211AA\262
\202'\310>A@\203I\311\262
\202'\312\313@\"\210\202'\210\314\315&\207" [plist-member :name :namespace-tag :id :attributes :attribute-groups :kind (:name :namespace-tag :id :attributes :attribute-groups :kind :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :id :attributes :attribute-groups :kind)" record soap-xs-basic-type] 15 (#$ . 37011)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-soap-xs-basic-type side-effect-free t cl-struct-define soap-xs-basic-type nil soap-xs-type record ((cl-tag-slot) (name nil) (namespace-tag nil) (id nil) (attributes nil) (attribute-groups nil) (kind)) cl-struct-soap-xs-basic-type-tags] 11)
#@158 Construct NAMESPACE-NAME containing the XMLSchema basic types.
An optional NAMESPACE-TAG can also be specified.

(fn NAMESPACE-NAME &optional NAMESPACE-TAG)
(defalias 'soap-make-xs-basic-types #[513 "\300\301\"\302\211\203#\211@\303\304\301\305\306\307!&\"\210
A\266\202\202\210\211\207" [make-soap-namespace :name ("string" "language" "ID" "IDREF" "dateTime" "time" "date" "boolean" "gYearMonth" "gYear" "gMonthDay" "gDay" "gMonth" "long" "short" "int" "integer" "nonNegativeInteger" "unsignedLong" "unsignedShort" "unsignedInt" "decimal" "duration" "byte" "unsignedByte" "float" "double" "base64Binary" "anyType" "anyURI" "QName" "Array" "byte[]") soap-namespace-put make-soap-xs-basic-type :namespace-tag :kind intern] 14 (#$ . 38049)])
#@296 Encode the XML attributes for VALUE according to TYPE.
The xsi:type and an optional xsi:nil attributes are added.  The
attributes are inserted in the current buffer at the current
position.

This is a specialization of `soap-encode-attributes' for
`soap-xs-basic-type' objects.

(fn VALUE TYPE)
(defalias 'soap-encode-xs-basic-type-attributes #[514 "\301
!\302!>\204\303\304\305D\"\210
\306H\211\307=\203J;\203)\310\262\311\262
\202J\250\2037\312\262\313\262
\202J\314>\203F\315\262\316\262
\202J\317\320!\210\321\322\261\210\206W\211\316=?\205]\323c\207" [cl-struct-soap-xs-basic-type-tags soap-element-fq-name type-of signal wrong-type-argument soap-xs-basic-type 6 anyType "xsd:string" string "xsd:int" int (t nil) "xsd:boolean" boolean error "Cannot classify anyType value" " xsi:type=\"" "\"" " xsi:nil=\"true\""] 7 (#$ . 38807)])
#@205 Encode the VALUE according to TYPE.
The data is inserted in the current buffer at the current
position.

This is a specialization of `soap-encode-value' for
`soap-xs-basic-type' objects.

(fn VALUE TYPE)
(defalias 'soap-encode-xs-basic-type #[514 "\301
!>\204\302\303\304D\"\210\211\305H<\203\306!@\202
\307=\203K\211;\2030\310\262\202K\211\250\203;\311\262\202K\211\312>\203G\313\262\202K\314\315!\210\211\204U
\313=\205\"

\316\267\202
\211;\204e\314\317\"\210\320
!\202
\211:\203\250\321\322\267\202\227\323\202\240\324\202\240\325\202\240\326\202\240\327\202\240\330\202\240\331\202\240\332\202\240\314\333\334#\205\240\335\336P\337#\202
\211;\203\270\340
\"\210\320
!\202
\314\341!\202
\211\342>\204\310\314\343!\210\211\203\320\344\202
\345\202
\211\250\204\335\314\346!\210
\347>\203\355\211\350W\203\355\314\351!\210\352
!\202
\211\247\204\374\314\353!\210\352
!\202
\211;\204
\314\354!\210\355
!\202
\314\356\357!#\360
\"\210\211c\262
\207" [cl-struct-soap-xs-basic-type-tags type-of signal wrong-type-argument soap-xs-basic-type 6 last anyType string int (t nil) boolean error "Cannot classify anyType value" #s(hash-table size 29 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (string 91 anyURI 91 QName 91 ID 91 IDREF 91 language 91 dateTime 107 time 107 date 107 gYearMonth 107 gYear 107 gMonthDay 107 gDay 107 gMonth 107 boolean 190 long 212 short 212 int 212 integer 212 byte 212 unsignedInt 212 unsignedLong 212 unsignedShort 212 nonNegativeInteger 212 decimal 212 duration 212 float 243 double 243 base64Binary 258)) "Not a string value: %s" url-insert-entities-in-string format-time-string #s(hash-table size 8 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (dateTime 119 time 123 date 127 gYearMonth 131 gYear 135 gMonthDay 139 gDay 143 gMonth 147)) "%Y-%m-%dT%H:%M:%S" "%H:%M:%S" "%Y-%m-%d" "%Y-%m" "%Y" "--%m-%d" "---%d" "--%m" "cl-ecase failed: %s, %s" (dateTime time date gYearMonth gYear gMonthDay gDay gMonth) nil "Z" t soap-decode-date-time "Invalid date-time format" (t nil) "Not a boolean value" "true" "false" "Not an integer value" (unsignedInt unsignedLong unsignedShort nonNegativeInteger) 0 "Not a positive integer" number-to-string "Not a number" "Not a string value for base64Binary" base64-encode-string "Don't know how to encode %s for type %s" soap-element-fq-name soap-validate-xs-basic-type] 9 (#$ . 39673)])
#@1053 Decode DATE-TIME-STRING as DATATYPE.
DATE-TIME-STRING should be in ISO 8601 basic or extended format.
DATATYPE is one of dateTime, time, date, gYearMonth, gYear,
gMonthDay, gDay or gMonth.

Return a list in a format (SEC MINUTE HOUR DAY MONTH YEAR
SEC-FRACTION DATATYPE ZONE).  This format is meant to be similar
to that returned by `decode-time' (and compatible with
`encode-time').  The differences are the SEC (seconds)
field is always an integer, the DOW (day-of-week) field
is replaced with SEC-FRACTION, a float representing the
fractional seconds, and the DST (daylight savings time) field is
replaced with DATATYPE, a symbol representing the XSD primitive
datatype.  This symbol can be used to determine which fields
apply and which don't when it's not already clear from context.
For example a datatype of `time' means the year, month and day
fields should be ignored.

This function will throw an error if DATE-TIME-STRING represents
a leap second, since the XML Schema 1.1 standard explicitly
disallows them.

(fn DATE-TIME-STRING DATATYPE)
(defalias 'soap-decode-date-time #[514 "\211\300NA@\301
\"\210\302\303\"\302\304\"\302\305\"\302\306\"\302\307\"\302\310	\"\302\311\n\"\302\312\"\302\313\f\"\302\314
\"\302\315\"\302\316\"\203M\317\202N\303\262\f\n\203_\320\f!_\202`\321\262	\203n\320\n!\202o\303\262\n\203}\320	!\202~\303\262	\203\214\320!\202\215\322\262\203\233\320!\202\234\322\262\203\251\320!\202\252\322\262\203\271\323\320!!\202\272\324\262\205\301\325\262\326\232\203\315\317\202\316\303\262
\203\332\320!\202\333\322\262\211\203\347\320
!\202\350\322\262
\n\322V\203R
	\303Y\203R
	\316X\203R
\303Y\203R
\327\f\f\"X\203R
\322Y\203R
\330X\203R
\322Y\203R
\331X\203R
\322Y\203R
\331X\203R

\322Y\203R

\330X\203R
\211\322Y\203R
\211\331X\204X
\332\333\"\210	
\n\203y
\334\n\n\322#_\202z
\322\257	\207" [rng-xsd-convert string-match match-string 1 2 3 4 5 6 7 8 9 10 11 12 -1 string-to-number 1970 0 float 0.0 t "-" rng-xsd-days-in-month 23 59 error "Invalid or unsupported time: %s" rng-xsd-time-to-seconds] 27 (#$ . 42125)])
#@254 Use TYPE, a `soap-xs-basic-type', to decode the contents of NODE.
A LISP value is returned based on the contents of NODE and the
type-info stored in TYPE.

This is a specialization of `soap-decode-type' for
`soap-xs-basic-type' objects.

(fn TYPE NODE)
(defalias 'soap-decode-xs-basic-type #[514 "\211\211AA\262
\302!>\204\303\304\305D\"\210\306H\211A@\262
\307\211\203R\211@\310
@!
A
\310\311!\232\203;\312
	\"\262
\310\313!\232\203I\211\227\314\230\262\266
A\266\202\202!\210\211\204b\315\206^\316C@\"\210\205\243\317\267\202\232@\202\243@\202\243\320@!\202\243@\227\314\230\202\243\321@!\202\243\322!\202\243\323!\202\243\324\325\326#\205\243\307\207" [cl-struct-soap-xs-basic-type-tags soap-current-wsdl type-of signal wrong-type-argument soap-xs-basic-type 6 nil soap-l2fq "xsi:type" soap-wsdl-get "xsi:nil" "true" soap-validate-xs-basic-type "" #s(hash-table size 31 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (string 108 anyURI 108 QName 108 ID 108 IDREF 108 language 108 dateTime 113 time 113 date 113 gYearMonth 113 gYear 113 gMonthDay 113 gDay 113 gMonth 113 long 118 short 118 int 118 integer 118 unsignedInt 118 unsignedLong 118 unsignedShort 118 nonNegativeInteger 118 decimal 118 byte 118 float 118 double 118 duration 118 boolean 125 base64Binary 133 anyType 140 Array 147)) string-to-number base64-decode-string soap-decode-any-type soap-decode-array error "cl-ecase failed: %s, %s" (language IDREF ID QName anyURI string gMonth gDay gMonthDay gYear gYearMonth date time dateTime duration double float byte decimal nonNegativeInteger unsignedShort unsignedLong unsignedInt integer int short long boolean base64Binary anyType Array)] 14 (#$ . 44300)])
(byte-code "\300\301\302\303\304\305\211\211\211\211\211&!\304=\203\302\202\306\"\210\301\303\304\305\211\211\211\211\211&!\307
\310\311#\210\307
\312\313#\210\307
\314\315#\210\207" [defalias soap-type-of type-of record soap-xs-basic-type nil #[257 "\300
!\203\n\211\301H\207\302
!\207" [vectorp 0 type-of] 3 "Return the type of ELEMENT.\n\n(fn ELEMENT)"] put soap-attribute-encoder soap-encode-xs-basic-type-attributes soap-encoder soap-encode-xs-basic-type soap-decoder soap-decode-xs-basic-type] 11)
#@74 compiler-macro for inlining `soap-xs-element-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-element-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-element-p (and (memq (type-of cl-x) cl-struct-soap-xs-element-tags) t)) nil] 9 (#$ . 46547)])
(put 'soap-xs-element-p 'compiler-macro 'soap-xs-element-p--cmacro)
#@13 

(fn CL-X)
(defalias 'soap-xs-element-p #[257 "\301
!>\205	\302\207" [cl-struct-soap-xs-element-tags type-of t] 3 (#$ . 46912)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put soap-xs-element-p side-effect-free error-free put soap-xs-element cl-deftype-satisfies] 5)
#@77 compiler-macro for inlining `soap-xs-element-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-element-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-element-name (progn (or (soap-xs-element-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-element cl-x))) (aref cl-x 1))) nil] 9 (#$ . 47207)])
(put 'soap-xs-element-name 'compiler-macro 'soap-xs-element-name--cmacro)
#@65 Access slot "name" of `soap-xs-element' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-element-name #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-element-tags type-of signal wrong-type-argument soap-xs-element 1] 5 (#$ . 47637)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-element-name side-effect-free t] 4)
#@86 compiler-macro for inlining `soap-xs-element-namespace-tag'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-element-namespace-tag--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-element-namespace-tag (progn (or (soap-xs-element-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-element cl-x))) (aref cl-x 2))) nil] 9 (#$ . 47995)])
(put 'soap-xs-element-namespace-tag 'compiler-macro 'soap-xs-element-namespace-tag--cmacro)
#@74 Access slot "namespace-tag" of `soap-xs-element' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-element-namespace-tag #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-element-tags type-of signal wrong-type-argument soap-xs-element 2] 5 (#$ . 48470)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-element-namespace-tag side-effect-free t] 4)
#@75 compiler-macro for inlining `soap-xs-element-id'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-element-id--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-element-id (progn (or (soap-xs-element-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-element cl-x))) (aref cl-x 3))) nil] 9 (#$ . 48855)])
(put 'soap-xs-element-id 'compiler-macro 'soap-xs-element-id--cmacro)
#@63 Access slot "id" of `soap-xs-element' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-element-id #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-element-tags type-of signal wrong-type-argument soap-xs-element 3] 5 (#$ . 49275)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-element-id side-effect-free t] 4)
#@78 compiler-macro for inlining `soap-xs-element-type^'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-element-type^--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-element-type^ (progn (or (soap-xs-element-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-element cl-x))) (aref cl-x 4))) nil] 9 (#$ . 49627)])
(put 'soap-xs-element-type^ 'compiler-macro 'soap-xs-element-type^--cmacro)
#@66 Access slot "type^" of `soap-xs-element' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-element-type^ #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-element-tags type-of signal wrong-type-argument soap-xs-element 4] 5 (#$ . 50062)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-element-type^ side-effect-free t] 4)
#@82 compiler-macro for inlining `soap-xs-element-optional?'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-element-optional\?--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-element-optional\? (progn (or (soap-xs-element-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-element cl-x))) (aref cl-x 5))) nil] 9 (#$ . 50423)])
(put 'soap-xs-element-optional\? 'compiler-macro 'soap-xs-element-optional\?--cmacro)
#@70 Access slot "optional?" of `soap-xs-element' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-element-optional\? #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-element-tags type-of signal wrong-type-argument soap-xs-element 5] 5 (#$ . 50882)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-element-optional\? side-effect-free t] 4)
#@82 compiler-macro for inlining `soap-xs-element-multiple?'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-element-multiple\?--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-element-multiple\? (progn (or (soap-xs-element-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-element cl-x))) (aref cl-x 6))) nil] 9 (#$ . 51257)])
(put 'soap-xs-element-multiple\? 'compiler-macro 'soap-xs-element-multiple\?--cmacro)
#@70 Access slot "multiple?" of `soap-xs-element' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-element-multiple\? #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-element-tags type-of signal wrong-type-argument soap-xs-element 6] 5 (#$ . 51716)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-element-multiple\? side-effect-free t] 4)
#@82 compiler-macro for inlining `soap-xs-element-reference'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-element-reference--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-element-reference (progn (or (soap-xs-element-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-element cl-x))) (aref cl-x 7))) nil] 9 (#$ . 52091)])
(put 'soap-xs-element-reference 'compiler-macro 'soap-xs-element-reference--cmacro)
#@70 Access slot "reference" of `soap-xs-element' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-element-reference #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-element-tags type-of signal wrong-type-argument soap-xs-element 7] 5 (#$ . 52546)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-element-reference side-effect-free t] 4)
#@91 compiler-macro for inlining `soap-xs-element-substitution-group'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-element-substitution-group--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-element-substitution-group (progn (or (soap-xs-element-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-element cl-x))) (aref cl-x 8))) nil] 9 (#$ . 52919)])
(put 'soap-xs-element-substitution-group 'compiler-macro 'soap-xs-element-substitution-group--cmacro)
#@79 Access slot "substitution-group" of `soap-xs-element' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-element-substitution-group #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-element-tags type-of signal wrong-type-argument soap-xs-element 8] 5 (#$ . 53419)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-element-substitution-group side-effect-free t] 4)
#@85 compiler-macro for inlining `soap-xs-element-alternatives'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-element-alternatives--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-element-alternatives (progn (or (soap-xs-element-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-element cl-x))) (aref cl-x 9))) nil] 9 (#$ . 53819)])
(put 'soap-xs-element-alternatives 'compiler-macro 'soap-xs-element-alternatives--cmacro)
#@73 Access slot "alternatives" of `soap-xs-element' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-element-alternatives #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-element-tags type-of signal wrong-type-argument soap-xs-element 9] 5 (#$ . 54289)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-element-alternatives side-effect-free t] 4)
#@81 compiler-macro for inlining `soap-xs-element-is-group'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-element-is-group--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-element-is-group (progn (or (soap-xs-element-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-element cl-x))) (aref cl-x 10))) nil] 9 (#$ . 54671)])
(put 'soap-xs-element-is-group 'compiler-macro 'soap-xs-element-is-group--cmacro)
#@69 Access slot "is-group" of `soap-xs-element' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-element-is-group #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-element-tags type-of signal wrong-type-argument soap-xs-element 10] 5 (#$ . 55122)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put soap-xs-element-is-group side-effect-free t defalias copy-soap-xs-element copy-sequence] 4)
#@188 compiler-macro for inlining `make-soap-xs-element'.

(fn CL-WHOLE &cl-quote &key NAME NAMESPACE-TAG ID TYPE^ OPTIONAL\=\? MULTIPLE\=\? REFERENCE SUBSTITUTION-GROUP ALTERNATIVES IS-GROUP)
(defalias 'make-soap-xs-element--cmacro #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\300\307\"A@\300\310\"A@\300	\311\"A@\300\n\312\"A@\n\211\203n\211@\313>\203V\211AA\262
\202C\314\f>A@\203e\315\262
\202C\316\317@\"\210\202C\210\320\321\322\315\315&\207" [plist-member :name :namespace-tag :id :type^ :optional\? :multiple\? :reference :substitution-group :alternatives :is-group (:name :namespace-tag :id :type^ :optional\? :multiple\? :reference :substitution-group :alternatives :is-group :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :id :type^ :optional? :multiple? :reference :substitution-group :alternatives :is-group)" cl--defsubst-expand (name namespace-tag id type^ optional\? multiple\? reference substitution-group alternatives is-group) (cl-block make-soap-xs-element (record 'soap-xs-element name namespace-tag id type^ optional\? multiple\? reference substitution-group alternatives is-group))] 28 (#$ . 55548)])
(put 'make-soap-xs-element 'compiler-macro 'make-soap-xs-element--cmacro)
#@168 Constructor for objects of type `soap-xs-element'.

(fn &key NAME NAMESPACE-TAG ID TYPE^ OPTIONAL\=\? MULTIPLE\=\? REFERENCE SUBSTITUTION-GROUP ALTERNATIVES IS-GROUP)
(defalias 'make-soap-xs-element #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\300\307\"A@\300\310\"A@\300	\311\"A@\300\n\312\"A@\n\211\203n\211@\313>\203V\211AA\262
\202C\314\f>A@\203e\315\262
\202C\316\317@\"\210\202C\210\320\321&\207" [plist-member :name :namespace-tag :id :type^ :optional\? :multiple\? :reference :substitution-group :alternatives :is-group (:name :namespace-tag :id :type^ :optional\? :multiple\? :reference :substitution-group :alternatives :is-group :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :id :type^ :optional? :multiple? :reference :substitution-group :alternatives :is-group)" record soap-xs-element] 23 (#$ . 56881)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-soap-xs-element side-effect-free t cl-struct-define soap-xs-element nil soap-element record ((cl-tag-slot) (name nil) (namespace-tag nil) (id) (type^) (optional\?) (multiple\?) (reference) (substitution-group) (alternatives) (is-group)) cl-struct-soap-xs-element-tags] 11)
#@166 Retrieve the type of ELEMENT.
This is normally stored in the TYPE^ slot, but if this element
contains a reference, retrieve the type of the reference.

(fn ELEMENT)
(defalias 'soap-xs-element-type #[257 "\301
!>\204\302\303\304D\"\210\211\305H\203*\306\301!>\204%\302\303\304D\"\210
\305H!\207\301
!>\2049\302\303\304D\"\210\211\307H\207" [cl-struct-soap-xs-element-tags type-of signal wrong-type-argument soap-xs-element 7 soap-xs-element-type 4] 6 (#$ . 58208)])
#@60 Return t if NODE specifies an optional element.

(fn NODE)
(defalias 'soap-node-optional #[257 "\300
\301\"\302\232\206\300
\303\"\211\205\211\304\232\262
\207" [xml-get-attribute-or-nil nillable "true" minOccurs "0"] 4 (#$ . 58691)])
#@56 Return t if NODE permits multiple elements.

(fn NODE)
(defalias 'soap-node-multiple #[257 "\300
\301\"\211\205\f\211\302\232?\207" [xml-get-attribute-or-nil maxOccurs "1"] 4 (#$ . 58936)])
#@53 Construct a `soap-xs-element' from NODE.

(fn NODE)
(defalias 'soap-xs-parse-element #[257 "\301
\302\"\301\303\"\301\304\"\305!\306!\301\307\"\301\310\"\311\211@\262
!\211\312>\2042\313\314\211C\315$\210\203=\316\317\"\262\203G\316\317\"\262
\203Q\316\317\"\262\204\203\204\203\320	\321\"\211\203k\322
@!\262\202\202\320\n\323\"\211\203}\324
@!\262\202\201\325\326!\210\210\210\327\330	\n\n\n\n\n\n\315\331=&\207" [soap-target-xmlns xml-get-attribute-or-nil name id type soap-node-optional soap-node-multiple ref substitutionGroup soap-l2wk #1=(xsd:element xsd:group) cl--assertion-failed (memq node-name '#1#) nil soap-l2fq tns soap-xml-get-children1 xsd:simpleType soap-xs-parse-simple-type xsd:complexType soap-xs-parse-complex-type error "Soap-xs-parse-element: missing type or ref" record soap-xs-element xsd:group] 22 (#$ . 59133)])
#@213 Replace names in ELEMENT with the referenced objects in the WSDL.
This is a specialization of `soap-resolve-references' for
`soap-xs-element' objects.

See also `soap-wsdl-resolve-references'.

(fn ELEMENT WSDL)
(defalias 'soap-resolve-references-for-xs-element #[514 "\303!>\204\304\305\306D\"\210
\307H\211\2039\310
\311!\"@\211\2038\303!>\2041\304\305\306D\"\210\211\307I\266\210\210\303!	>\204I\304\305\312D\"\210
\313H\314
!\203p\303!	>\204a\304\305\312D\"\210\211\313\315\316#I\266\202}\303
!\n>\203}\317
\"\210\210\303!	>\204\215\304\305\312D\"\210
\320H\314
!\203\306\303!	>\204\245\304\305\312D\"\210\321H\204\306\303!	>\204\272\304\305\312D\"\210\211\320\315\322#I\266\210\303!	>\204\326\304\305\312D\"\210
\323H\314
!\205
\315
\"\211\203
\303
!	>\204\366\304\305\312D\"\210\211\211\324\324HBI\262
\202
\325C\326\327\330\331#\332#\266\202\262
\207" [cl-struct-soap-element-tags cl-struct-soap-xs-element-tags cl-struct-soap-xs-type-tags type-of signal wrong-type-argument soap-element 2 rassoc soap-wsdl-alias-table soap-xs-element 4 soap-name-p soap-wsdl-get soap-xs-type-p soap-resolve-references 7 10 soap-xs-element-p 8 9 "No target found for substitution-group" display-warning soap-client apply format :warning] 12 (#$ . 60027)])
#@203 Encode the XML attributes for VALUE according to ELEMENT.
Currently no attributes are needed.

This is a specialization of `soap-encode-attributes' for
`soap-xs-basic-type' objects.

(fn VALUE ELEMENT)
(defalias 'soap-encode-xs-element-attributes #[514 "\300\207" [nil] 3 (#$ . 61343)])
#@85 Return t if VALUE should be encoded for ELEMENT, nil otherwise.

(fn VALUE ELEMENT)
(defalias 'soap-should-encode-value-for-xs-element #[514 "
\203\302\207\303
!\304
!>\205%\304
!>\204 \305\306\307D\"\210\211\310H\311=\262
\206d\303
!\3122^\304
!	>\204@\305\306\313D\"\210\211\314H\211\205[\211@\315
!\203T\316\312\302\"\210
A\266\202\202C\262
0\262
\206d\317\207" [cl-struct-soap-xs-basic-type-tags cl-struct-soap-xs-type-tags t soap-xs-element-type type-of signal wrong-type-argument soap-xs-basic-type 6 boolean found soap-xs-type 4 soap-xs-attribute-default throw nil] 8 (#$ . 61636)])
#@47 Return t if TYPE defines an ARRAY.

(fn TYPE)
(defalias 'soap-type-is-array\? #[257 "\300
!\205\301
!\302=\207" [soap-xs-complex-type-p soap-xs-complex-type-indicator array] 3 (#$ . 62247)])
#@257 A list of namespace tags used during encoding a message.
This list is populated by `soap-encode-value' and used by
`soap-create-envelope' to add aliases for these namespace to the
XML request.

This variable is dynamically bound in `soap-create-envelope'.
(defvar soap-encoded-namespaces nil (#$ . 62447))
#@211 Encode the VALUE according to ELEMENT.
The data is inserted in the current buffer at the current
position.

This is a specialization of `soap-encode-value' for
`soap-xs-basic-type' objects.

(fn VALUE ELEMENT)
(defalias 'soap-encode-xs-element #[514 "\304
!\305!\306!>\204\307\310\311D\"\210\312H\203\331\313\"\205\344\314\261\210\315\"\210\204O\306
!	>\203\324\306
!	>\204G\307\310\316D\"\210\211\317H\320=\203\324\321c\210\322
!\203\307\323!\306!>\204j\307\310\311D\"\210
\324H\203\222\306!>\204\307\310\311D\"\210
\324H\211\n\235\203\215\n\210\202\221\211\nB\210\306
!>\204\241\307\310\325D\"\210\211\211\326\327!I\266\330G

W\203\302\331H\"\210
T\262\202\255\266\202\314\332\"\210\333\334\261\202\344\335c\202\344\313\"\205\344\332\"\207" [cl-struct-soap-element-tags cl-struct-soap-xs-basic-type-tags soap-encoded-namespaces cl-struct-soap-xs-element-tags soap-element-fq-name soap-xs-element-type type-of signal wrong-type-argument soap-element 1 soap-should-encode-value-for-xs-element "<" soap-encode-attributes soap-xs-basic-type 6 boolean ">" soap-type-is-array\? copy-soap-xs-element 2 soap-xs-element 4 soap-xs-complex-type-base 0 soap-encode-xs-element soap-encode-value "</" ">\n" "/>\n"] 10 (#$ . 62760)])
#@260 Use ELEMENT, a `soap-xs-element', to decode the contents of NODE.
A LISP value is returned based on the contents of NODE and the
type-info stored in ELEMENT.

This is a specialization of `soap-decode-type' for
`soap-xs-basic-type' objects.

(fn ELEMENT NODE)
(defalias 'soap-decode-xs-element #[514 "\300!\301
\"\207" [soap-xs-element-type soap-decode-type] 6 (#$ . 64050)])
(byte-code "\300\301\302\303\211\211\211\211\211\211\211\211\211&!\304
\305\306#\210\304
\307\310#\210\304
\311\312#\210\304
\313\314#\210\207" [soap-type-of record soap-xs-element nil put soap-resolve-references soap-resolve-references-for-xs-element soap-attribute-encoder soap-encode-xs-element-attributes soap-encoder soap-encode-xs-element soap-decoder soap-decode-xs-element] 13)
#@76 compiler-macro for inlining `soap-xs-attribute-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-attribute-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-attribute-p (and (memq (type-of cl-x) cl-struct-soap-xs-attribute-tags) t)) nil] 9 (#$ . 64820)])
(put 'soap-xs-attribute-p 'compiler-macro 'soap-xs-attribute-p--cmacro)
#@13 

(fn CL-X)
(defalias 'soap-xs-attribute-p #[257 "\301
!>\205	\302\207" [cl-struct-soap-xs-attribute-tags type-of t] 3 (#$ . 65197)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put soap-xs-attribute-p side-effect-free error-free put soap-xs-attribute cl-deftype-satisfies] 5)
#@79 compiler-macro for inlining `soap-xs-attribute-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-attribute-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-attribute-name (progn (or (soap-xs-attribute-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-attribute cl-x))) (aref cl-x 1))) nil] 9 (#$ . 65500)])
(put 'soap-xs-attribute-name 'compiler-macro 'soap-xs-attribute-name--cmacro)
#@67 Access slot "name" of `soap-xs-attribute' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-attribute-name #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-attribute-tags type-of signal wrong-type-argument soap-xs-attribute 1] 5 (#$ . 65944)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-attribute-name side-effect-free t] 4)
#@88 compiler-macro for inlining `soap-xs-attribute-namespace-tag'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-attribute-namespace-tag--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-attribute-namespace-tag (progn (or (soap-xs-attribute-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-attribute cl-x))) (aref cl-x 2))) nil] 9 (#$ . 66312)])
(put 'soap-xs-attribute-namespace-tag 'compiler-macro 'soap-xs-attribute-namespace-tag--cmacro)
#@76 Access slot "namespace-tag" of `soap-xs-attribute' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-attribute-namespace-tag #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-attribute-tags type-of signal wrong-type-argument soap-xs-attribute 2] 5 (#$ . 66801)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-attribute-namespace-tag side-effect-free t] 4)
#@79 compiler-macro for inlining `soap-xs-attribute-type'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-attribute-type--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-attribute-type (progn (or (soap-xs-attribute-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-attribute cl-x))) (aref cl-x 3))) nil] 9 (#$ . 67196)])
(put 'soap-xs-attribute-type 'compiler-macro 'soap-xs-attribute-type--cmacro)
#@67 Access slot "type" of `soap-xs-attribute' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-attribute-type #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-attribute-tags type-of signal wrong-type-argument soap-xs-attribute 3] 5 (#$ . 67640)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-attribute-type side-effect-free t] 4)
#@82 compiler-macro for inlining `soap-xs-attribute-default'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-attribute-default--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-attribute-default (progn (or (soap-xs-attribute-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-attribute cl-x))) (aref cl-x 4))) nil] 9 (#$ . 68008)])
(put 'soap-xs-attribute-default 'compiler-macro 'soap-xs-attribute-default--cmacro)
#@70 Access slot "default" of `soap-xs-attribute' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-attribute-default #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-attribute-tags type-of signal wrong-type-argument soap-xs-attribute 4] 5 (#$ . 68467)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-attribute-default side-effect-free t] 4)
#@84 compiler-macro for inlining `soap-xs-attribute-reference'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-attribute-reference--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-attribute-reference (progn (or (soap-xs-attribute-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-attribute cl-x))) (aref cl-x 5))) nil] 9 (#$ . 68844)])
(put 'soap-xs-attribute-reference 'compiler-macro 'soap-xs-attribute-reference--cmacro)
#@72 Access slot "reference" of `soap-xs-attribute' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-attribute-reference #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-attribute-tags type-of signal wrong-type-argument soap-xs-attribute 5] 5 (#$ . 69313)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put soap-xs-attribute-reference side-effect-free t defalias copy-soap-xs-attribute copy-sequence] 4)
#@127 compiler-macro for inlining `make-soap-xs-attribute'.

(fn CL-WHOLE &cl-quote &key NAME NAMESPACE-TAG TYPE DEFAULT REFERENCE)
(defalias 'make-soap-xs-attribute--cmacro #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\211\203J\211@\306>\2032\211AA\262
\202\307>A@\203A\310\262
\202\311\312@\"\210\202\210\313\314\315\310\n\310\n\n\n\n\n&\n\207" [plist-member :name :namespace-tag :type :default :reference (:name :namespace-tag :type :default :reference :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :type :default :reference)" cl--defsubst-expand (name namespace-tag type default reference) (cl-block make-soap-xs-attribute (record 'soap-xs-attribute name namespace-tag type default reference))] 18 (#$ . 69753)])
(put 'make-soap-xs-attribute 'compiler-macro 'make-soap-xs-attribute--cmacro)
#@107 Constructor for objects of type `soap-xs-attribute'.

(fn &key NAME NAMESPACE-TAG TYPE DEFAULT REFERENCE)
(defalias 'make-soap-xs-attribute #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\211\203J\211@\306>\2032\211AA\262
\202\307>A@\203A\310\262
\202\311\312@\"\210\202\210\313\314&\207" [plist-member :name :namespace-tag :type :default :reference (:name :namespace-tag :type :default :reference :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :type :default :reference)" record soap-xs-attribute] 13 (#$ . 70650)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-soap-xs-attribute side-effect-free t cl-struct-define soap-xs-attribute nil soap-element record ((cl-tag-slot) (name nil) (namespace-tag nil) (type) (default) (reference)) cl-struct-soap-xs-attribute-tags] 11)
#@82 compiler-macro for inlining `soap-xs-attribute-group-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-attribute-group-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-attribute-group-p (and (memq (type-of cl-x) cl-struct-soap-xs-attribute-group-tags) t)) nil] 9 (#$ . 71582)])
(put 'soap-xs-attribute-group-p 'compiler-macro 'soap-xs-attribute-group-p--cmacro)
#@13 

(fn CL-X)
(defalias 'soap-xs-attribute-group-p #[257 "\301
!>\205	\302\207" [cl-struct-soap-xs-attribute-group-tags type-of t] 3 (#$ . 71995)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put soap-xs-attribute-group-p side-effect-free error-free put soap-xs-attribute-group cl-deftype-satisfies] 5)
#@85 compiler-macro for inlining `soap-xs-attribute-group-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-attribute-group-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-attribute-group-name (progn (or (soap-xs-attribute-group-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-attribute-group cl-x))) (aref cl-x 1))) nil] 9 (#$ . 72322)])
(put 'soap-xs-attribute-group-name 'compiler-macro 'soap-xs-attribute-group-name--cmacro)
#@73 Access slot "name" of `soap-xs-attribute-group' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-attribute-group-name #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-attribute-group-tags type-of signal wrong-type-argument soap-xs-attribute-group 1] 5 (#$ . 72808)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-attribute-group-name side-effect-free t] 4)
#@94 compiler-macro for inlining `soap-xs-attribute-group-namespace-tag'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-attribute-group-namespace-tag--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-attribute-group-namespace-tag (progn (or (soap-xs-attribute-group-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-attribute-group cl-x))) (aref cl-x 2))) nil] 9 (#$ . 73206)])
(put 'soap-xs-attribute-group-namespace-tag 'compiler-macro 'soap-xs-attribute-group-namespace-tag--cmacro)
#@82 Access slot "namespace-tag" of `soap-xs-attribute-group' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-attribute-group-namespace-tag #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-attribute-group-tags type-of signal wrong-type-argument soap-xs-attribute-group 2] 5 (#$ . 73737)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-attribute-group-namespace-tag side-effect-free t] 4)
#@83 compiler-macro for inlining `soap-xs-attribute-group-id'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-attribute-group-id--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-attribute-group-id (progn (or (soap-xs-attribute-group-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-attribute-group cl-x))) (aref cl-x 3))) nil] 9 (#$ . 74162)])
(put 'soap-xs-attribute-group-id 'compiler-macro 'soap-xs-attribute-group-id--cmacro)
#@71 Access slot "id" of `soap-xs-attribute-group' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-attribute-group-id #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-attribute-group-tags type-of signal wrong-type-argument soap-xs-attribute-group 3] 5 (#$ . 74638)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-attribute-group-id side-effect-free t] 4)
#@91 compiler-macro for inlining `soap-xs-attribute-group-attributes'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-attribute-group-attributes--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-attribute-group-attributes (progn (or (soap-xs-attribute-group-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-attribute-group cl-x))) (aref cl-x 4))) nil] 9 (#$ . 75030)])
(put 'soap-xs-attribute-group-attributes 'compiler-macro 'soap-xs-attribute-group-attributes--cmacro)
#@79 Access slot "attributes" of `soap-xs-attribute-group' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-attribute-group-attributes #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-attribute-group-tags type-of signal wrong-type-argument soap-xs-attribute-group 4] 5 (#$ . 75546)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-attribute-group-attributes side-effect-free t] 4)
#@97 compiler-macro for inlining `soap-xs-attribute-group-attribute-groups'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-attribute-group-attribute-groups--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-attribute-group-attribute-groups (progn (or (soap-xs-attribute-group-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-attribute-group cl-x))) (aref cl-x 5))) nil] 9 (#$ . 75962)])
(put 'soap-xs-attribute-group-attribute-groups 'compiler-macro 'soap-xs-attribute-group-attribute-groups--cmacro)
#@85 Access slot "attribute-groups" of `soap-xs-attribute-group' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-attribute-group-attribute-groups #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-attribute-group-tags type-of signal wrong-type-argument soap-xs-attribute-group 5] 5 (#$ . 76508)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-attribute-group-attribute-groups side-effect-free t] 4)
#@90 compiler-macro for inlining `soap-xs-attribute-group-reference'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-attribute-group-reference--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-attribute-group-reference (progn (or (soap-xs-attribute-group-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-attribute-group cl-x))) (aref cl-x 6))) nil] 9 (#$ . 76942)])
(put 'soap-xs-attribute-group-reference 'compiler-macro 'soap-xs-attribute-group-reference--cmacro)
#@78 Access slot "reference" of `soap-xs-attribute-group' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-attribute-group-reference #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-attribute-group-tags type-of signal wrong-type-argument soap-xs-attribute-group 6] 5 (#$ . 77453)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put soap-xs-attribute-group-reference side-effect-free t defalias copy-soap-xs-attribute-group copy-sequence] 4)
#@151 compiler-macro for inlining `make-soap-xs-attribute-group'.

(fn CL-WHOLE &cl-quote &key NAME NAMESPACE-TAG ID ATTRIBUTES ATTRIBUTE-GROUPS REFERENCE)
(defalias 'make-soap-xs-attribute-group--cmacro #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\211\203R\211@\307>\203:\211AA\262
\202'\310>A@\203I\311\262
\202'\312\313@\"\210\202'\210\314\315\316\311\311&\207" [plist-member :name :namespace-tag :id :attributes :attribute-groups :reference (:name :namespace-tag :id :attributes :attribute-groups :reference :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :id :attributes :attribute-groups :reference)" cl--defsubst-expand (name namespace-tag id attributes attribute-groups reference) (cl-block make-soap-xs-attribute-group (record 'soap-xs-attribute-group name namespace-tag id attributes attribute-groups reference))] 20 (#$ . 77929)])
(put 'make-soap-xs-attribute-group 'compiler-macro 'make-soap-xs-attribute-group--cmacro)
#@131 Constructor for objects of type `soap-xs-attribute-group'.

(fn &key NAME NAMESPACE-TAG ID ATTRIBUTES ATTRIBUTE-GROUPS REFERENCE)
(defalias 'make-soap-xs-attribute-group #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\211\203R\211@\307>\203:\211AA\262
\202'\310>A@\203I\311\262
\202'\312\313@\"\210\202'\210\314\315&\207" [plist-member :name :namespace-tag :id :attributes :attribute-groups :reference (:name :namespace-tag :id :attributes :attribute-groups :reference :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :id :attributes :attribute-groups :reference)" record soap-xs-attribute-group] 15 (#$ . 78983)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-soap-xs-attribute-group side-effect-free t cl-struct-define soap-xs-attribute-group nil soap-xs-type record ((cl-tag-slot) (name nil) (namespace-tag nil) (id nil) (attributes nil) (attribute-groups nil) (reference)) cl-struct-soap-xs-attribute-group-tags] 11)
#@55 Construct a `soap-xs-attribute' from NODE.

(fn NODE)
(defalias 'soap-xs-parse-attribute #[257 "\300
\211@\262
!\301=\204 \302\303\300\211@\262
!\300\211@\262
!C\304$\210\305
\306\"\307\305\310\"!\305\311\"\305\312\"\211\2059\307
!\204J\211\204J\313\314\315\"!\262\316\317\304&\207" [soap-l2wk xsd:attribute cl--assertion-failed (eq (soap-l2wk (xml-node-name node)) 'xsd:attribute) nil xml-get-attribute-or-nil name soap-l2fq type fixed ref soap-xs-parse-simple-type soap-xml-node-find-matching-child (xsd:restriction xsd:list xsd:union) record soap-xs-attribute] 13 (#$ . 80075)])
#@61 Construct a `soap-xs-attribute-group' from NODE.

(fn NODE)
(defalias 'soap-xs-parse-attribute-group #[257 "\302
\211@\262
!\211\303=\204\304\305\211C\306$\210\307\310\"\307\311\"\307\312\"\306\2038
\2038\313C\314\315\316\317#\320#\266\321\322\323\324\205H\325!&\262

\204\266\211AA\262
\211\203\265\211@\211;\204\256\302
\211@\262
!\211\326\267\202\255\327!\330!>\204\201\331\332\333D\"\210\211\334\334HBI\266\202\255\335!\330!	>\204\242\331\332\336D\"\210\211\337\337HBI\266\210
A\266\202\202V\210\266\203\207" [cl-struct-soap-xs-type-tags cl-struct-soap-xs-attribute-group-tags soap-l2wk xsd:attributeGroup cl--assertion-failed (eq node-name 'xsd:attributeGroup) nil xml-get-attribute-or-nil name id ref "name and ref set for attribute group %s" display-warning soap-client apply format :warning make-soap-xs-attribute-group :id :name :reference soap-l2fq #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (xsd:attribute 110 xsd:attributeGroup 143)) soap-xs-parse-attribute type-of signal wrong-type-argument soap-xs-type 4 soap-xs-parse-attribute-group soap-xs-attribute-group 5] 16 (#$ . 80685)])
#@219 Replace names in ATTRIBUTE with the referenced objects in the WSDL.
This is a specialization of `soap-resolve-references' for
`soap-xs-attribute' objects.

See also `soap-wsdl-resolve-references'.

(fn ATTRIBUTE WSDL)
(defalias 'soap-resolve-references-for-xs-attribute #[514 "\302!>\204\303\304\305D\"\210
\306H\302!>\204!\303\304\305D\"\210\307H\310\311!\205/
@\312\232\211\203<\313\262\314\262\202q\311!\203c\302!>\204S\303\304\305D\"\210\211\306\315	\316#I\266\202q\302!	>\203q\317\"\210\311!\205\226\302!>\204\210\303\304\305D\"\210\211\307\315	#I\262
\207" [cl-struct-soap-xs-attribute-tags cl-struct-soap-xs-type-tags type-of signal wrong-type-argument soap-xs-attribute 3 5 soap-xs-element-p soap-name-p "http://www.w3.org/XML/1998/namespace" ("http://www.w3.org/2001/XMLSchema" . "string") soap-xs-basic-type-p soap-wsdl-get #[257 "\301
!>\203\n\302\207\303
!\207" [cl-struct-soap-xs-basic-type-tags type-of t soap-xs-simple-type-p] 3 "\n\n(fn TYPE)"] soap-resolve-references] 13 (#$ . 81877)])
(byte-code "\300\301\302\303\304\211\211\211\211&!\305\306#\207" [put soap-type-of record soap-xs-attribute nil soap-resolve-references soap-resolve-references-for-xs-attribute] 9)
#@231 Set slots in ATTRIBUTE-GROUP to the referenced objects in the WSDL.
This is a specialization of `soap-resolve-references' for
`soap-xs-attribute-group' objects.

See also `soap-wsdl-resolve-references'.

(fn ATTRIBUTE-GROUP WSDL)
(defalias 'soap-resolve-references-for-xs-attribute-group #[514 "\301!>\204\302\303\304D\"\210
\305H\306
!\205
\307
\310#\301
!>\204,\302\303\304D\"\210\211\311H\211\203B\211@\312
\"\210
A\266\202\202/\210\301!>\204S\302\303\304D\"\210\211\313\301!>\204f\302\303\304D\"\210\313HI\266\301!>\204|\302\303\304D\"\210\211\314\301!>\204\217\302\303\304D\"\210\314HI\266\301!>\204\245\302\303\304D\"\210\211\305\315I\266\301!>\204\274\302\303\304D\"\210\211\311\301!>\204\317\302\303\304D\"\210\311HI\266\301!>\204\345\302\303\304D\"\210\211\316\301!>\204\370\302\303\304D\"\210\316HI\262
\262
\207" [cl-struct-soap-xs-attribute-group-tags type-of signal wrong-type-argument soap-xs-attribute-group 6 soap-name-p soap-wsdl-get soap-xs-attribute-group-p 4 soap-resolve-references 1 3 nil 5] 11 (#$ . 83121)])
(byte-code "\300\301\302\303\304\211\211\211\211\211&!\305\306#\207" [put soap-type-of record soap-xs-attribute-group nil soap-resolve-references soap-resolve-references-for-xs-attribute-group] 10)
#@78 compiler-macro for inlining `soap-xs-simple-type-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-simple-type-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-simple-type-p (and (memq (type-of cl-x) cl-struct-soap-xs-simple-type-tags) t)) nil] 9 (#$ . 84430)])
(put 'soap-xs-simple-type-p 'compiler-macro 'soap-xs-simple-type-p--cmacro)
#@13 

(fn CL-X)
(defalias 'soap-xs-simple-type-p #[257 "\301
!>\205	\302\207" [cl-struct-soap-xs-simple-type-tags type-of t] 3 (#$ . 84819)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put soap-xs-simple-type-p side-effect-free error-free put soap-xs-simple-type cl-deftype-satisfies] 5)
#@81 compiler-macro for inlining `soap-xs-simple-type-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-simple-type-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-simple-type-name (progn (or (soap-xs-simple-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-simple-type cl-x))) (aref cl-x 1))) nil] 9 (#$ . 85130)])
(put 'soap-xs-simple-type-name 'compiler-macro 'soap-xs-simple-type-name--cmacro)
#@69 Access slot "name" of `soap-xs-simple-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-simple-type-name #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-simple-type-tags type-of signal wrong-type-argument soap-xs-simple-type 1] 5 (#$ . 85588)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-simple-type-name side-effect-free t] 4)
#@90 compiler-macro for inlining `soap-xs-simple-type-namespace-tag'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-simple-type-namespace-tag--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-simple-type-namespace-tag (progn (or (soap-xs-simple-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-simple-type cl-x))) (aref cl-x 2))) nil] 9 (#$ . 85966)])
(put 'soap-xs-simple-type-namespace-tag 'compiler-macro 'soap-xs-simple-type-namespace-tag--cmacro)
#@78 Access slot "namespace-tag" of `soap-xs-simple-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-simple-type-namespace-tag #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-simple-type-tags type-of signal wrong-type-argument soap-xs-simple-type 2] 5 (#$ . 86469)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-simple-type-namespace-tag side-effect-free t] 4)
#@79 compiler-macro for inlining `soap-xs-simple-type-id'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-simple-type-id--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-simple-type-id (progn (or (soap-xs-simple-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-simple-type cl-x))) (aref cl-x 3))) nil] 9 (#$ . 86874)])
(put 'soap-xs-simple-type-id 'compiler-macro 'soap-xs-simple-type-id--cmacro)
#@67 Access slot "id" of `soap-xs-simple-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-simple-type-id #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-simple-type-tags type-of signal wrong-type-argument soap-xs-simple-type 3] 5 (#$ . 87322)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-simple-type-id side-effect-free t] 4)
#@87 compiler-macro for inlining `soap-xs-simple-type-attributes'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-simple-type-attributes--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-simple-type-attributes (progn (or (soap-xs-simple-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-simple-type cl-x))) (aref cl-x 4))) nil] 9 (#$ . 87694)])
(put 'soap-xs-simple-type-attributes 'compiler-macro 'soap-xs-simple-type-attributes--cmacro)
#@75 Access slot "attributes" of `soap-xs-simple-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-simple-type-attributes #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-simple-type-tags type-of signal wrong-type-argument soap-xs-simple-type 4] 5 (#$ . 88182)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-simple-type-attributes side-effect-free t] 4)
#@93 compiler-macro for inlining `soap-xs-simple-type-attribute-groups'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-simple-type-attribute-groups--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-simple-type-attribute-groups (progn (or (soap-xs-simple-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-simple-type cl-x))) (aref cl-x 5))) nil] 9 (#$ . 88578)])
(put 'soap-xs-simple-type-attribute-groups 'compiler-macro 'soap-xs-simple-type-attribute-groups--cmacro)
#@81 Access slot "attribute-groups" of `soap-xs-simple-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-simple-type-attribute-groups #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-simple-type-tags type-of signal wrong-type-argument soap-xs-simple-type 5] 5 (#$ . 89096)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-simple-type-attribute-groups side-effect-free t] 4)
#@81 compiler-macro for inlining `soap-xs-simple-type-base'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-simple-type-base--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-simple-type-base (progn (or (soap-xs-simple-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-simple-type cl-x))) (aref cl-x 6))) nil] 9 (#$ . 89510)])
(put 'soap-xs-simple-type-base 'compiler-macro 'soap-xs-simple-type-base--cmacro)
#@69 Access slot "base" of `soap-xs-simple-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-simple-type-base #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-simple-type-tags type-of signal wrong-type-argument soap-xs-simple-type 6] 5 (#$ . 89968)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-simple-type-base side-effect-free t] 4)
#@88 compiler-macro for inlining `soap-xs-simple-type-enumeration'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-simple-type-enumeration--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-simple-type-enumeration (progn (or (soap-xs-simple-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-simple-type cl-x))) (aref cl-x 7))) nil] 9 (#$ . 90346)])
(put 'soap-xs-simple-type-enumeration 'compiler-macro 'soap-xs-simple-type-enumeration--cmacro)
#@76 Access slot "enumeration" of `soap-xs-simple-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-simple-type-enumeration #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-simple-type-tags type-of signal wrong-type-argument soap-xs-simple-type 7] 5 (#$ . 90839)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-simple-type-enumeration side-effect-free t] 4)
#@84 compiler-macro for inlining `soap-xs-simple-type-pattern'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-simple-type-pattern--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-simple-type-pattern (progn (or (soap-xs-simple-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-simple-type cl-x))) (aref cl-x 8))) nil] 9 (#$ . 91238)])
(put 'soap-xs-simple-type-pattern 'compiler-macro 'soap-xs-simple-type-pattern--cmacro)
#@72 Access slot "pattern" of `soap-xs-simple-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-simple-type-pattern #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-simple-type-tags type-of signal wrong-type-argument soap-xs-simple-type 8] 5 (#$ . 91711)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-simple-type-pattern side-effect-free t] 4)
#@89 compiler-macro for inlining `soap-xs-simple-type-length-range'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-simple-type-length-range--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-simple-type-length-range (progn (or (soap-xs-simple-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-simple-type cl-x))) (aref cl-x 9))) nil] 9 (#$ . 92098)])
(put 'soap-xs-simple-type-length-range 'compiler-macro 'soap-xs-simple-type-length-range--cmacro)
#@77 Access slot "length-range" of `soap-xs-simple-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-simple-type-length-range #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-simple-type-tags type-of signal wrong-type-argument soap-xs-simple-type 9] 5 (#$ . 92596)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-simple-type-length-range side-effect-free t] 4)
#@90 compiler-macro for inlining `soap-xs-simple-type-integer-range'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-simple-type-integer-range--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-simple-type-integer-range (progn (or (soap-xs-simple-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-simple-type cl-x))) (aref cl-x 10))) nil] 9 (#$ . 92998)])
(put 'soap-xs-simple-type-integer-range 'compiler-macro 'soap-xs-simple-type-integer-range--cmacro)
#@78 Access slot "integer-range" of `soap-xs-simple-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-simple-type-integer-range #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-simple-type-tags type-of signal wrong-type-argument soap-xs-simple-type 10] 5 (#$ . 93502)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-simple-type-integer-range side-effect-free t] 4)
#@84 compiler-macro for inlining `soap-xs-simple-type-is-list'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-simple-type-is-list--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-simple-type-is-list (progn (or (soap-xs-simple-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-simple-type cl-x))) (aref cl-x 11))) nil] 9 (#$ . 93908)])
(put 'soap-xs-simple-type-is-list 'compiler-macro 'soap-xs-simple-type-is-list--cmacro)
#@72 Access slot "is-list" of `soap-xs-simple-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-simple-type-is-list #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-simple-type-tags type-of signal wrong-type-argument soap-xs-simple-type 11] 5 (#$ . 94382)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put soap-xs-simple-type-is-list side-effect-free t defalias copy-soap-xs-simple-type copy-sequence] 4)
#@197 compiler-macro for inlining `make-soap-xs-simple-type'.

(fn CL-WHOLE &cl-quote &key NAME NAMESPACE-TAG ID ATTRIBUTES ATTRIBUTE-GROUPS BASE ENUMERATION PATTERN LENGTH-RANGE INTEGER-RANGE IS-LIST)
(defalias 'make-soap-xs-simple-type--cmacro #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\300\307\"A@\300\310\"A@\300	\311\"A@\300\n\312\"A@\300\313\"A@\211\203u\211@\314>\203]\211AA\262
\202J\315
>A@\203l\316\262
\202J\317\320@\"\210\202J\210\321\322\323\316\316&\207" [plist-member :name :namespace-tag :id :attributes :attribute-groups :base :enumeration :pattern :length-range :integer-range :is-list (:name :namespace-tag :id :attributes :attribute-groups :base :enumeration :pattern :length-range :integer-range :is-list :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :id :attributes :attribute-groups :base :enumeration :pattern :length-range :integer-range :is-list)" cl--defsubst-expand (name namespace-tag id attributes attribute-groups base enumeration pattern length-range integer-range is-list) (cl-block make-soap-xs-simple-type (record 'soap-xs-simple-type name namespace-tag id attributes attribute-groups base enumeration pattern length-range integer-range is-list))] 30 (#$ . 94829)])
(put 'make-soap-xs-simple-type 'compiler-macro 'make-soap-xs-simple-type--cmacro)
#@177 Constructor for objects of type `soap-xs-simple-type'.

(fn &key NAME NAMESPACE-TAG ID ATTRIBUTES ATTRIBUTE-GROUPS BASE ENUMERATION PATTERN LENGTH-RANGE INTEGER-RANGE IS-LIST)
(defalias 'make-soap-xs-simple-type #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\300\307\"A@\300\310\"A@\300	\311\"A@\300\n\312\"A@\300\313\"A@\211\203u\211@\314>\203]\211AA\262
\202J\315
>A@\203l\316\262
\202J\317\320@\"\210\202J\210\321\322\f\f\f\f\f\f\f\f\f\f\f&\f\207" [plist-member :name :namespace-tag :id :attributes :attribute-groups :base :enumeration :pattern :length-range :integer-range :is-list (:name :namespace-tag :id :attributes :attribute-groups :base :enumeration :pattern :length-range :integer-range :is-list :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :id :attributes :attribute-groups :base :enumeration :pattern :length-range :integer-range :is-list)" record soap-xs-simple-type] 25 (#$ . 96255)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-soap-xs-simple-type side-effect-free t cl-struct-define soap-xs-simple-type nil soap-xs-type record ((cl-tag-slot) (name nil) (namespace-tag nil) (id nil) (attributes nil) (attribute-groups nil) (base) (enumeration) (pattern) (length-range) (integer-range) (is-list)) cl-struct-soap-xs-simple-type-tags] 11)
#@73 Construct an `soap-xs-simple-type' object from the XML NODE.

(fn NODE)
(defalias 'soap-xs-parse-simple-type #[257 "\301
\211@\262
!\302>\204\303\304\305\306\301\211@\262
!C$\210\307
\310\"\307\311\"\312\313\306\211\211\211\211\211\211\211&\f\314\315\"\301
\211@\262
!\211\316\267\202b\317\"\210\202h\320\"\210\202h\321\"\210\202h\322\"\210\202h\323\324\325#\210\210
\266\202\207" [soap-target-xmlns soap-l2wk #1=(xsd:simpleType xsd:simpleContent) cl--assertion-failed (memq (soap-l2wk (xml-node-name node)) '#1#) "expecting xsd:simpleType or xsd:simpleContent node, got %s" nil xml-get-attribute-or-nil name id record soap-xs-simple-type soap-xml-node-find-matching-child (xsd:restriction xsd:extension xsd:union xsd:list) #s(hash-table size 4 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (xsd:restriction 66 xsd:extension 74 xsd:union 82 xsd:list 90)) soap-xs-add-restriction soap-xs-add-extension soap-xs-add-union soap-xs-add-list error "cl-ecase failed: %s, %s" (xsd:restriction xsd:extension xsd:union xsd:list)] 16 (#$ . 97691)])
#@89 Add restrictions defined in XML NODE to TYPE, an `soap-xs-simple-type'.

(fn NODE TYPE)
(defalias 'soap-xs-add-restriction #[514 "\301\211@\262
!\302=\204\303\304\305\306\301\211@\262
!C$\210\307
!>\204*\310\311\312D\"\210\211\211\313\314\315\316\"\2068\317\266\202!I\266
\211AA\262
\211\205\302\211@\211;\204\273\211\320\316\"\206Y\317\266\202\301\211@\262
!\211\321\267\202\271\307!>\204x\310\311\312D\"\210\211\322\322HBI\266\202\271\307!>\204\226\310\311\312D\"\210\211\323\324\325!\326QI\266\202\271\327!\307!>\204\272\310\311\312D\"\210\211\330\211BI\266\202\271\327!\307!>\204\332\310\311\312D\"\210\211\330\307	!>\204\356\310\311\312D\"\210\330H\203
\307\n!>\204
\310\311\312\fD\"\210	\330HAB\202
\306BI\266\202\271\327!\307!>\204-
\310\311\312D\"\210\211\330\307	!>\204A
\310\311\312D\"\210\330H\203c
\307	!>\204Y
\310\311\312D\"\210\330H@B\202f
\306BI\266\202\271\327!\307!>\204\200
\310\311\312D\"\210\211\331\307	!>\204\224
\310\311\312D\"\210\331H\203\267
T\307\n!>\204\256
\310\311\312\fD\"\210	\331HAB\202\273
T\306BI\266\202\271\327!\307!>\204\325
\310\311\312D\"\210\211\331\307	!>\204\351
\310\311\312D\"\210\331H\203\f\307	!>\204
\310\311\312D\"\210\331H@SB\202\306SBI\266\202\271\327!\307!>\204*\310\311\312D\"\210\211\331\307	!>\204>\310\311\312D\"\210\331H\203`\307\n!>\204W\310\311\312\fD\"\210	\331HAB\202c\306BI\266\202\271\327!\307!>\204}\310\311\312D\"\210\211\331\307	!>\204\221\310\311\312D\"\210\331H\203\263\307	!>\204\251\310\311\312D\"\210\331H@B\202\266\306BI\266\266
A\266\202\202D\207" [cl-struct-soap-xs-simple-type-tags soap-l2wk xsd:restriction cl--assertion-failed (eq (soap-l2wk (xml-node-name node)) 'xsd:restriction) "expecting xsd:restriction node, got %s" nil type-of signal wrong-type-argument soap-xs-simple-type 6 soap-l2fq base xml-get-attribute-or-nil "" value #s(hash-table size 9 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (xsd:enumeration 104 xsd:pattern 134 xsd:length 166 xsd:minLength 198 xsd:maxLength 281 xsd:minExclusive 364 xsd:maxExclusive 449 xsd:minInclusive 534 xsd:maxInclusive 617)) 7 8 "\\`" xsdre-translate "\\'" string-to-number 9 10] 15 (#$ . 98775)])
#@90 Add union members defined in XML NODE to TYPE, an `soap-xs-simple-type'.

(fn NODE TYPE)
(defalias 'soap-xs-add-union #[514 "\301\211@\262
!\302=\204\303\304\305\306\301\211@\262
!C$\210\307
!>\204*\310\311\312D\"\210\211\211\313\314\315\316\317\320\"\2069\321!\"I\266\306\322\323\"\211\203W\211@\324
!B\262
A\266\202\202C\210\307!>\204g\310\311\312D\"\210
\211\313\325\307!>\204|\310\311\312D\"\210\313H\237\"I\262
\207" [cl-struct-soap-xs-simple-type-tags soap-l2wk xsd:union cl--assertion-failed (eq (soap-l2wk (xml-node-name node)) 'xsd:union) "expecting xsd:union node, got %s" nil type-of signal wrong-type-argument soap-xs-simple-type 6 mapcar soap-l2fq split-string xml-get-attribute-or-nil memberTypes "" soap-xml-get-children1 xsd:simpleType soap-xs-parse-simple-type append] 11 (#$ . 101127)])
#@80 Add list defined in XML NODE to TYPE, a `soap-xs-simple-type'.

(fn NODE TYPE)
(defalias 'soap-xs-add-list #[514 "\302\211@\262
!\303=\204\304\305\306\307\302\211@\262
!C$\210\310\311\"\312\313\"
\203l\211G\314U\203I\315!>\204=\316\317\320D\"\210\211\321\322!I\266\202\263\323\315!	>\204Z\316\317\324D\"\210\325HC\326\327\330\331#\332#\266\202\263\211G\325U\203\223\315!>\204\202\316\317\320D\"\210\211\321\333\312\313\"@!I\266\202\263\334\315!	>\204\244\316\317\324D\"\210\325HC\326\327\330\331#\332#\266\315!>\204\302\316\317\320D\"\210\211\335\336I\262
\207" [cl-struct-soap-xs-simple-type-tags cl-struct-soap-xs-type-tags soap-l2wk xsd:list cl--assertion-failed (eq (soap-l2wk (xml-node-name node)) 'xsd:list) "expecting xsd:list node, got %s" nil xml-get-attribute-or-nil itemType soap-xml-get-children1 xsd:simpleType 0 type-of signal wrong-type-argument soap-xs-simple-type 6 soap-l2fq "xsd:list node with itemType has more than zero children: %s" soap-xs-type 1 display-warning soap-client apply format :warning soap-xs-parse-simple-type "xsd:list node has more than one child %s" 11 t] 12 (#$ . 101967)])
#@94 Add the extended type defined in XML NODE to TYPE, an `soap-xs-simple-type'.

(fn NODE TYPE)
(defalias 'soap-xs-add-extension #[514 "\302
!>\204\303\304\305D\"\210\211\211\306\307\310\311\"\206\312\266\202!I\266\313\314\"\211\203R\211@\315
!\302!	>\204@\303\304\316D\"\210\211\317\317HBI\266
A\266\202\202'\210\313\320\"\211\205\202\211@\321
!\302!	>\204p\303\304\316D\"\210\211\322\322HBI\266
A\266\202\202W\207" [cl-struct-soap-xs-simple-type-tags cl-struct-soap-xs-type-tags type-of signal wrong-type-argument soap-xs-simple-type 6 soap-l2fq base xml-get-attribute-or-nil "" soap-xml-get-children1 xsd:attribute soap-xs-parse-attribute soap-xs-type 4 xsd:attributeGroup soap-xs-parse-attribute-group 5] 11 (#$ . 103136)])
#@62 Validate VALUE against the basic type TYPE.

(fn VALUE TYPE)
(defalias 'soap-validate-xs-basic-type #[514 "\301
!>\204\302\303\304D\"\210\211\305H\306
\307\"\203\202H\211\310N\211\203B\211\311@AB\"\266\202\2037\202F\312\313\314!#\202F\312\315\"\262
\207" [cl-struct-soap-xs-basic-type-tags type-of signal wrong-type-argument soap-xs-basic-type 6 memql (anyType Array byte []) rng-xsd-convert apply error "Invalid %s: %s" symbol-name "Don't know how to convert %s"] 10 (#$ . 103899)])
#@67 Validate VALUE against the restrictions of TYPE.

(fn VALUE TYPE)
(defalias 'soap-validate-xs-simple-type #[514 "\304
!>\204\305\306\307D\"\210\211\310H\311C
<\203u\3122q
\211\203a\211@\3131O\304
!>\203;\314\312\315\"\"\202K\304
!	>\205K\314\312\316\"\"0\202Y
A@\242B\240\262
\210
A\266\202\202\210\211\242\205p\317\320\321\242\237\322#!0\210\202\247
\311\323\324\325\326\327!\330\"\310\331%\262
\3322m
\304!>\204\231\305\306\307D\"\210\333H\211G\334V\203\256
\235\204\256
\335\"\210\210\304!>\204\277\305\306\307D\"\210\336H\211\203\334\211\311\337\340#)\266\203\204\334
\341\"\210\210\304!>\204\355\305\306\307D\"\210\342H\211\203$
;\204\376
\343\"\210\211@\203
G
@Y\204

\344@\"\210\211A\203$
G
AX\204$

\345A\"\210\210\304!>\2045
\305\306\307D\"\210\346H\211\205j
\247\204F

\347\"\210\211@\203X

@Y\204X

\350@\"\210\211A\205j

AX?\205j

\351A\"\262
0\266\211\242\203\247
\317\352\304!>\204\210
\305\306\353D\"\210\334H\206\242
\304!>\204\237
\305\306\353D\"\210\354H\242@$\210\266
\207" [cl-struct-soap-xs-simple-type-tags cl-struct-soap-xs-basic-type-tags inhibit-changing-match-data cl-struct-soap-xs-type-tags type-of signal wrong-type-argument soap-xs-simple-type 6 nil valid (error) throw soap-validate-xs-simple-type soap-validate-xs-basic-type error mapconcat identity "; and: " make-byte-code 514 "\300\301\"\300\242B\240\210\302\303\304\"\207" vconcat vector [format throw invalid nil] "\n\n(fn FORMAT VALUE)" invalid 7 1 "bad value, should be one of %s" 8 t string-match "bad value, should match pattern %s" 9 "bad value, should be a string with length range %s" "short string, should be at least %s chars" "long string, should be at most %s chars" 10 "bad value, should be a number with range %s" "small value, should be at least %s" "big value, should be at most %s" "Xs-simple-type(%s, %s): %s" soap-xs-type 3] 13 (#$ . 104410)])
#@211 Replace names in TYPE with the referenced objects in the WSDL.
This is a specialization of `soap-resolve-references' for
`soap-xs-simple-type' objects.

See also `soap-wsdl-resolve-references'.

(fn TYPE WSDL)
(defalias 'soap-resolve-references-for-xs-simple-type #[514 "\303!>\204\304\305\306D\"\210
\307H\211\2039\310
\311!\"@\211\2038\303!>\2041\304\305\306D\"\210\211\307I\266\210\210\303!	>\204I\304\305\312D\"\210
\313H\314
!\203p\303!	>\204a\304\305\312D\"\210\211\313\315\316#I\266\202\261\303
!\n>\203\200\317
\"\210\202\261\211<\203\255\303!	>\204\224\304\305\312D\"\210\211\313\320\321\322\323\324\325\n!\326\"\327\330%\"I\266\202\261\331\332!\210\210\303!\n>\204\301\304\305\333D\"\210
\334H\211\203\326\211@\317
\"\210
A\266\202\202\304\210\303!\n>\204\346\304\305\333D\"\210
\327H\211\205\373\211@\317
\"\210
A\266\202\202\351\207" [cl-struct-soap-element-tags cl-struct-soap-xs-simple-type-tags cl-struct-soap-xs-type-tags type-of signal wrong-type-argument soap-element 2 rassoc soap-wsdl-alias-table soap-xs-simple-type 6 soap-name-p soap-wsdl-get soap-xs-type-p soap-resolve-references mapcar make-byte-code 257 "\302
!\203\f\303
\300\304#\207\305
!	>\203\306
\300\"\210\207\207" vconcat vector [cl-struct-soap-xs-type-tags soap-name-p soap-wsdl-get soap-xs-type-p type-of soap-resolve-references] 5 "\n\n(fn TYPE)" error "Oops" soap-xs-type 4] 13 (#$ . 106362)])
#@333 Encode the XML attributes for VALUE according to TYPE.
The attributes are inserted in the current buffer at the current
position.  If TYPE has no attributes, the xsi:type attribute and
an optional xsi:nil attribute are added.

This is a specialization of `soap-encode-attributes' for
`soap-xs-simple-type' objects.

(fn VALUE TYPE)
(defalias 'soap-encode-xs-simple-type-attributes #[514 "\302
!\211\211\203w\211@\303
!>\204\304\305\306D\"\210\211\307H\303!	>\204+\304\305\310D\"\210
\311H\203N\312
\313\303!	>\204D\304\305\310D\"\210\311H\314\261\210\202o\211\203n\211@\315\242!\232\203g\312\313A\314\261\210
A\266\202\202O\210\210
A\266\202\202\210\211?\205\214\316\317!\314\261\210?\205\214\320c\207" [cl-struct-soap-element-tags cl-struct-soap-xs-attribute-tags soap-get-xs-attributes type-of signal wrong-type-argument soap-element 1 soap-xs-attribute 4 " " "=\"" "\"" symbol-name " xsi:type=\"" soap-element-fq-name " xsi:nil=\"true\""] 13 (#$ . 107807)])
#@206 Encode the VALUE according to TYPE.
The data is inserted in the current buffer at the current
position.

This is a specialization of `soap-encode-value' for
`soap-xs-simple-type' objects.

(fn VALUE TYPE)
(defalias 'soap-encode-xs-simple-type #[514 "\301\"\210\302
!>\204\303\304\305D\"\210\211\306H\203^\307!\211\203D\211@\310
\302!>\2045\303\304\305D\"\210\311H\"\210\312c\210
A\266\202\202\210\310\313!@\302!>\204Y\303\304\305D\"\210\311H\"\207\310\302!>\204o\303\304\305D\"\210\311H\"\207" [cl-struct-soap-xs-simple-type-tags soap-validate-xs-simple-type type-of signal wrong-type-argument soap-xs-simple-type 11 butlast soap-encode-value 6 " " last] 10 (#$ . 108807)])
#@256 Use TYPE, a `soap-xs-simple-type', to decode the contents of NODE.
A LISP value is returned based on the contents of NODE and the
type-info stored in TYPE.

This is a specialization of `soap-decode-type' for
`soap-xs-simple-type' objects.

(fn TYPE NODE)
(defalias 'soap-decode-xs-simple-type #[514 "\301!>\204\302\303\304D\"\210
\305H\203\306
\211AA\262
@!\207\307\301!>\204/\302\303\304D\"\210\310H\"\311
\"\207" [cl-struct-soap-xs-simple-type-tags type-of signal wrong-type-argument soap-xs-simple-type 11 split-string soap-decode-type 6 soap-validate-xs-simple-type] 7 (#$ . 109517)])
(byte-code "\300\301\302\303\211\211\211\211\211\211\211\211\211\211&\f!\304
\305\306#\210\304
\307\310#\210\304
\311\312#\210\304
\313\314#\210\207" [soap-type-of record soap-xs-simple-type nil put soap-resolve-references soap-resolve-references-for-xs-simple-type soap-attribute-encoder soap-encode-xs-simple-type-attributes soap-encoder soap-encode-xs-simple-type soap-decoder soap-decode-xs-simple-type] 14)
#@79 compiler-macro for inlining `soap-xs-complex-type-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-complex-type-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-complex-type-p (and (memq (type-of cl-x) cl-struct-soap-xs-complex-type-tags) t)) nil] 9 (#$ . 110538)])
(put 'soap-xs-complex-type-p 'compiler-macro 'soap-xs-complex-type-p--cmacro)
#@13 

(fn CL-X)
(defalias 'soap-xs-complex-type-p #[257 "\301
!>\205	\302\207" [cl-struct-soap-xs-complex-type-tags type-of t] 3 (#$ . 110934)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put soap-xs-complex-type-p side-effect-free error-free put soap-xs-complex-type cl-deftype-satisfies] 5)
#@82 compiler-macro for inlining `soap-xs-complex-type-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-complex-type-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-complex-type-name (progn (or (soap-xs-complex-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-complex-type cl-x))) (aref cl-x 1))) nil] 9 (#$ . 111250)])
(put 'soap-xs-complex-type-name 'compiler-macro 'soap-xs-complex-type-name--cmacro)
#@70 Access slot "name" of `soap-xs-complex-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-complex-type-name #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-complex-type-tags type-of signal wrong-type-argument soap-xs-complex-type 1] 5 (#$ . 111716)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-complex-type-name side-effect-free t] 4)
#@91 compiler-macro for inlining `soap-xs-complex-type-namespace-tag'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-complex-type-namespace-tag--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-complex-type-namespace-tag (progn (or (soap-xs-complex-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-complex-type cl-x))) (aref cl-x 2))) nil] 9 (#$ . 112100)])
(put 'soap-xs-complex-type-namespace-tag 'compiler-macro 'soap-xs-complex-type-namespace-tag--cmacro)
#@79 Access slot "namespace-tag" of `soap-xs-complex-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-complex-type-namespace-tag #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-complex-type-tags type-of signal wrong-type-argument soap-xs-complex-type 2] 5 (#$ . 112611)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-complex-type-namespace-tag side-effect-free t] 4)
#@80 compiler-macro for inlining `soap-xs-complex-type-id'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-complex-type-id--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-complex-type-id (progn (or (soap-xs-complex-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-complex-type cl-x))) (aref cl-x 3))) nil] 9 (#$ . 113022)])
(put 'soap-xs-complex-type-id 'compiler-macro 'soap-xs-complex-type-id--cmacro)
#@68 Access slot "id" of `soap-xs-complex-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-complex-type-id #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-complex-type-tags type-of signal wrong-type-argument soap-xs-complex-type 3] 5 (#$ . 113478)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-complex-type-id side-effect-free t] 4)
#@88 compiler-macro for inlining `soap-xs-complex-type-attributes'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-complex-type-attributes--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-complex-type-attributes (progn (or (soap-xs-complex-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-complex-type cl-x))) (aref cl-x 4))) nil] 9 (#$ . 113856)])
(put 'soap-xs-complex-type-attributes 'compiler-macro 'soap-xs-complex-type-attributes--cmacro)
#@76 Access slot "attributes" of `soap-xs-complex-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-complex-type-attributes #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-complex-type-tags type-of signal wrong-type-argument soap-xs-complex-type 4] 5 (#$ . 114352)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-complex-type-attributes side-effect-free t] 4)
#@94 compiler-macro for inlining `soap-xs-complex-type-attribute-groups'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-complex-type-attribute-groups--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-complex-type-attribute-groups (progn (or (soap-xs-complex-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-complex-type cl-x))) (aref cl-x 5))) nil] 9 (#$ . 114754)])
(put 'soap-xs-complex-type-attribute-groups 'compiler-macro 'soap-xs-complex-type-attribute-groups--cmacro)
#@82 Access slot "attribute-groups" of `soap-xs-complex-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-complex-type-attribute-groups #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-complex-type-tags type-of signal wrong-type-argument soap-xs-complex-type 5] 5 (#$ . 115280)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-complex-type-attribute-groups side-effect-free t] 4)
#@87 compiler-macro for inlining `soap-xs-complex-type-indicator'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-complex-type-indicator--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-complex-type-indicator (progn (or (soap-xs-complex-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-complex-type cl-x))) (aref cl-x 6))) nil] 9 (#$ . 115700)])
(put 'soap-xs-complex-type-indicator 'compiler-macro 'soap-xs-complex-type-indicator--cmacro)
#@75 Access slot "indicator" of `soap-xs-complex-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-complex-type-indicator #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-complex-type-tags type-of signal wrong-type-argument soap-xs-complex-type 6] 5 (#$ . 116191)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-complex-type-indicator side-effect-free t] 4)
#@82 compiler-macro for inlining `soap-xs-complex-type-base'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-complex-type-base--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-complex-type-base (progn (or (soap-xs-complex-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-complex-type cl-x))) (aref cl-x 7))) nil] 9 (#$ . 116590)])
(put 'soap-xs-complex-type-base 'compiler-macro 'soap-xs-complex-type-base--cmacro)
#@70 Access slot "base" of `soap-xs-complex-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-complex-type-base #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-complex-type-tags type-of signal wrong-type-argument soap-xs-complex-type 7] 5 (#$ . 117056)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-complex-type-base side-effect-free t] 4)
#@86 compiler-macro for inlining `soap-xs-complex-type-elements'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-complex-type-elements--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-complex-type-elements (progn (or (soap-xs-complex-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-complex-type cl-x))) (aref cl-x 8))) nil] 9 (#$ . 117440)])
(put 'soap-xs-complex-type-elements 'compiler-macro 'soap-xs-complex-type-elements--cmacro)
#@74 Access slot "elements" of `soap-xs-complex-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-complex-type-elements #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-complex-type-tags type-of signal wrong-type-argument soap-xs-complex-type 8] 5 (#$ . 117926)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-complex-type-elements side-effect-free t] 4)
#@87 compiler-macro for inlining `soap-xs-complex-type-optional?'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-complex-type-optional\?--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-complex-type-optional\? (progn (or (soap-xs-complex-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-complex-type cl-x))) (aref cl-x 9))) nil] 9 (#$ . 118322)])
(put 'soap-xs-complex-type-optional\? 'compiler-macro 'soap-xs-complex-type-optional\?--cmacro)
#@75 Access slot "optional?" of `soap-xs-complex-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-complex-type-optional\? #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-complex-type-tags type-of signal wrong-type-argument soap-xs-complex-type 9] 5 (#$ . 118817)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-complex-type-optional\? side-effect-free t] 4)
#@87 compiler-macro for inlining `soap-xs-complex-type-multiple?'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-complex-type-multiple\?--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-complex-type-multiple\? (progn (or (soap-xs-complex-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-complex-type cl-x))) (aref cl-x 10))) nil] 9 (#$ . 119218)])
(put 'soap-xs-complex-type-multiple\? 'compiler-macro 'soap-xs-complex-type-multiple\?--cmacro)
#@75 Access slot "multiple?" of `soap-xs-complex-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-complex-type-multiple\? #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-complex-type-tags type-of signal wrong-type-argument soap-xs-complex-type 10] 5 (#$ . 119714)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-complex-type-multiple\? side-effect-free t] 4)
#@86 compiler-macro for inlining `soap-xs-complex-type-is-group'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-complex-type-is-group--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-complex-type-is-group (progn (or (soap-xs-complex-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-complex-type cl-x))) (aref cl-x 11))) nil] 9 (#$ . 120116)])
(put 'soap-xs-complex-type-is-group 'compiler-macro 'soap-xs-complex-type-is-group--cmacro)
#@74 Access slot "is-group" of `soap-xs-complex-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-complex-type-is-group #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-complex-type-tags type-of signal wrong-type-argument soap-xs-complex-type 11] 5 (#$ . 120603)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put soap-xs-complex-type-is-group side-effect-free t defalias copy-soap-xs-complex-type copy-sequence] 4)
#@197 compiler-macro for inlining `make-soap-xs-complex-type'.

(fn CL-WHOLE &cl-quote &key NAME NAMESPACE-TAG ID ATTRIBUTES ATTRIBUTE-GROUPS INDICATOR BASE ELEMENTS OPTIONAL\=\? MULTIPLE\=\? IS-GROUP)
(defalias 'make-soap-xs-complex-type--cmacro #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\300\307\"A@\300\310\"A@\300	\311\"A@\300\n\312\"A@\300\313\"A@\211\203u\211@\314>\203]\211AA\262
\202J\315
>A@\203l\316\262
\202J\317\320@\"\210\202J\210\321\322\323\316\316&\207" [plist-member :name :namespace-tag :id :attributes :attribute-groups :indicator :base :elements :optional\? :multiple\? :is-group (:name :namespace-tag :id :attributes :attribute-groups :indicator :base :elements :optional\? :multiple\? :is-group :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :id :attributes :attribute-groups :indicator :base :elements :optional? :multiple? :is-group)" cl--defsubst-expand (name namespace-tag id attributes attribute-groups indicator base elements optional\? multiple\? is-group) (cl-block make-soap-xs-complex-type (record 'soap-xs-complex-type name namespace-tag id attributes attribute-groups indicator base elements optional\? multiple\? is-group))] 30 (#$ . 121060)])
(put 'make-soap-xs-complex-type 'compiler-macro 'make-soap-xs-complex-type--cmacro)
#@177 Constructor for objects of type `soap-xs-complex-type'.

(fn &key NAME NAMESPACE-TAG ID ATTRIBUTES ATTRIBUTE-GROUPS INDICATOR BASE ELEMENTS OPTIONAL\=\? MULTIPLE\=\? IS-GROUP)
(defalias 'make-soap-xs-complex-type #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\300\307\"A@\300\310\"A@\300	\311\"A@\300\n\312\"A@\300\313\"A@\211\203u\211@\314>\203]\211AA\262
\202J\315
>A@\203l\316\262
\202J\317\320@\"\210\202J\210\321\322\f\f\f\f\f\f\f\f\f\f\f&\f\207" [plist-member :name :namespace-tag :id :attributes :attribute-groups :indicator :base :elements :optional\? :multiple\? :is-group (:name :namespace-tag :id :attributes :attribute-groups :indicator :base :elements :optional\? :multiple\? :is-group :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :id :attributes :attribute-groups :indicator :base :elements :optional? :multiple? :is-group)" record soap-xs-complex-type] 25 (#$ . 122465)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-soap-xs-complex-type side-effect-free t cl-struct-define soap-xs-complex-type nil soap-xs-type record ((cl-tag-slot) (name nil) (namespace-tag nil) (id nil) (attributes nil) (attribute-groups nil) (indicator) (base) (elements) (optional\?) (multiple\?) (is-group)) cl-struct-soap-xs-complex-type-tags] 11)
#@72 Construct a `soap-xs-complex-type' by parsing the XML NODE.

(fn NODE)
(defalias 'soap-xs-parse-complex-type #[257 "\303
\304\"\303\305\"\306\211@\262
!\307\211\211\310>\204!\311\312\313\307C$\210\211AA\262
\211\203\265\211@\211:\203\256\306
\211@\262
!\211\314\267\202\255\315!B\262\202\255\316!B\262\202\255\317!\262\202\255\320!\262\202\255
\211AA\262
\211\203\254\211@\211:\203\245\306
\211@\262
!\211\321\267\202\244\315!B\262\202\244\316!B\262\202\244\322!\262	\202\244\320!\210\210
A\266\202\202j\210\210
A\266\202\202(\210\204\313\323\324\307\211\211\211\211\211\211\211\211\211\211&\f\262\325!>\204\332\326\327\330D\"\210\211\331I\266\325!>\204\361\326\327\330D\"\210\211\332	I\266\325!>\204
\326\327\330D\"\210\211\333I\266\325!>\204
\326\327\330D\"\210\211\334\335\325!>\2044
\326\327\330\nD\"\210\334H\"I\266\325!>\204K
\326\327\330D\"\210\211\336\335\325!>\204a
\326\327\330\nD\"\210\336H\"I\266\325!\n>\203\212
\325!\n>\204\200
\326\327\324D\"\210\211\337\340=I\266\207" [cl-struct-soap-xs-type-tags soap-target-xmlns cl-struct-soap-xs-complex-type-tags xml-get-attribute-or-nil name id soap-l2wk nil #1=(xsd:complexType xsd:complexContent xsd:group) cl--assertion-failed (memq node-name '#1#) "unexpected node: %s" #s(hash-table size 7 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (xsd:attribute 64 xsd:attributeGroup 74 xsd:simpleContent 84 xsd:sequence 92 xsd:all 92 xsd:choice 92 xsd:complexContent 100)) soap-xs-parse-attribute soap-xs-parse-attribute-group soap-xs-parse-simple-type soap-xs-parse-sequence #s(hash-table size 7 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (xsd:attribute 130 xsd:attributeGroup 141 xsd:extension 152 xsd:restriction 152 xsd:sequence 160 xsd:all 160 xsd:choice 160)) soap-xs-parse-extension-or-restriction record soap-xs-complex-type type-of signal wrong-type-argument soap-xs-type 1 2 3 4 append 5 11 xsd:group] 20 (#$ . 123885)])
#@89 Parse a sequence definition from XML NODE.
Returns a `soap-xs-complex-type'.

(fn NODE)
(defalias 'soap-xs-parse-sequence #[257 "\302
\211@\262
!\303>\204\304\305\306\307\302\211@\262
!C$\210\310\311\307\211\211\211\211\211\211\211\211\211\211&\f\312
!>\2048\313\314\311D\"\210\211\211\315\302\211@\262
!\211\316\267\202T\317\202]\320\202]\321\202]\322\323\324#\205]\307\262
I\266\312
!>\204q\313\314\311D\"\210\211\211\325\326!I\266\312
!>\204\211\313\314\311D\"\210\211\211\327\330!I\266
\211AA\262
\211\203H
\211@\211;\204A
\302
\211@\262
!\211\331\267\202@
\332!\312!>\204\303\313\314\311D\"\210\211\333\333HBI\266\202@
\334!\310\335\307\211\211\307\211\211\211\211\211&\312!>\204\363\313\314\311D\"\210\211\333\333HBI\266\202@
\336!\312!	>\204
\313\314\337D\"\210\211\340\340HBI\266\202@
\341!\312!	>\2045
\313\314\337D\"\210\211\342\342HBI\266\210
A\266\202\202\230\210\312
!>\204X
\313\314\311D\"\210\211\211\333\312!>\204k
\313\314\311D\"\210\333H\237I\266\211\207" [cl-struct-soap-xs-complex-type-tags cl-struct-soap-xs-type-tags soap-l2wk #1=(xsd:sequence xsd:choice xsd:all) cl--assertion-failed (memq (soap-l2wk (xml-node-name node)) '#1#) "unexpected node: %s" nil record soap-xs-complex-type type-of signal wrong-type-argument 6 #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (xsd:sequence 72 xsd:all 76 xsd:choice 80)) sequence all choice error "cl-ecase failed: %s, %s" (xsd:sequence xsd:all xsd:choice) 9 soap-node-optional 10 soap-node-multiple #s(hash-table size 7 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (xsd:element 176 xsd:group 176 xsd:sequence 209 xsd:choice 209 xsd:all 209 xsd:attribute 257 xsd:attributeGroup 290)) soap-xs-parse-element 8 soap-xs-parse-sequence soap-xs-element soap-xs-parse-attribute soap-xs-type 4 soap-xs-parse-attribute-group 5] 18 (#$ . 125913)])
#@105 Parse an extension or restriction definition from XML NODE.
Return a `soap-xs-complex-type'.

(fn NODE)
(defalias 'soap-xs-parse-extension-or-restriction #[257 "\301
\211@\262
!\302>\204\303\304\305\306\301\211@\262
!C$\210\306\211\211\211\307\310\"\301\211@\262
!\311=\2054\211\312\313!\232\262\211AA\262
\211\203\224\211@\211:\203\215\301
\211@\262
!\211\314\267\202\214\315!\262\202\214\203y\316\317\"\211\203u\320\321\"\203u\322\323\"\262\210\202\214\324!B\262\202\214\325!B\262\210
A\266\202\202<\210\204\305\326\327\306\211\211\211\211\211\211\211\211\211\211&\f\262
\203\305\330!>\204\276\331\332\327D\"\210\211\333\334I\266\330!>\204\325\331\332\327D\"\210\211\335\336!I\266\330!>\204\356\331\332\327D\"\210\211\337I\266\330!>\204
\331\332\327D\"\210\211\340I\266\207" [cl-struct-soap-xs-complex-type-tags soap-l2wk #1=(xsd:extension xsd:restriction) cl--assertion-failed (memq (soap-l2wk (xml-node-name node)) '#1#) "unexpected node: %s" nil xml-get-attribute-or-nil base xsd:restriction soap-wk2l "soapenc:Array" #s(hash-table size 5 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (xsd:sequence 84 xsd:choice 84 xsd:all 84 xsd:attribute 92 xsd:attributeGroup 132)) soap-xs-parse-sequence soap-xml-get-attribute-or-nil1 wsdl:arrayType string-match "^\\(.*\\)\\[\\]$" match-string 1 soap-xs-parse-attribute soap-xs-parse-attribute-group record soap-xs-complex-type type-of signal wrong-type-argument 6 array 7 soap-l2fq 4 5] 19 (#$ . 127851)])
#@212 Replace names in TYPE with the referenced objects in the WSDL.
This is a specialization of `soap-resolve-references' for
`soap-xs-complex-type' objects.

See also `soap-wsdl-resolve-references'.

(fn TYPE WSDL)
(defalias 'soap-resolve-references-for-xs-complex-type #[514 "\304!>\204\305\306\307D\"\210
\310H\211\2039\311
\312!\"@\211\2038\304!>\2041\305\306\307D\"\210\211\310I\266\210\210\304!	>\204I\305\306\313D\"\210
\314H\315
!\203p\304!	>\204a\305\306\313D\"\210\211\314\316\317#I\266\202}\304
!\n>\203}\320
\"\210\210\321\304!	>\204\216\305\306\313D\"\210\322H\211\203
\211@\304
!>\204\246\305\306\323D\"\210\211\324H\203\362\316\304!>\204\274\305\306\323D\"\210
\314H\325#\304
!	>\204\321\305\306\313D\"\210\211\322H\211\203\355\211@\320
\"\210\211B\262
A\266\202\202\324\266\202\374\320
\"\210\211B\262
A\266\202\202\221\210\304!	>\204
\305\306\313D\"\210\211\322\237I\266\304!\n>\204*
\305\306\326D\"\210
\327H\211\203?
\211@\320
\"\210
A\266\202\202-
\210\304!\n>\204O
\305\306\326D\"\210
\330H\211\205d
\211@\320
\"\210
A\266\202\202R
\207" [cl-struct-soap-element-tags cl-struct-soap-xs-complex-type-tags cl-struct-soap-xs-type-tags cl-struct-soap-xs-element-tags type-of signal wrong-type-argument soap-element 2 rassoc soap-wsdl-alias-table soap-xs-complex-type 7 soap-name-p soap-wsdl-get soap-xs-type-p soap-resolve-references nil 8 soap-xs-element 10 #[257 "\301
!>\205\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-complex-type-tags type-of signal wrong-type-argument soap-xs-complex-type 11] 5 "\n\n(fn TYPE)"] soap-xs-type 4 5] 11 (#$ . 129398)])
#@371 Encode the XML attributes for encoding VALUE according to TYPE.
The xsi:type and optional xsi:nil attributes are added, plus
additional attributes needed for arrays types, if applicable.  The
attributes are inserted in the current buffer at the current
position.

This is a specialization of `soap-encode-attributes' for
`soap-xs-complex-type' objects.

(fn VALUE TYPE)
(defalias 'soap-encode-xs-complex-type-attributes #[514 "\303
!>\204\304\305\306D\"\210\211\307H\310=\203<\303
!>\204&\304\305\306D\"\210\211\311H\312c\210\313\314!\315\316\317G\"\320\321\261\207\322
!\211\203\262\211@\303
!	>\204T\304\305\323D\"\210\211\324H\303!\n>\204f\304\305\325D\"\210
\326H\203\211\327
\330\303!\n>\204\304\305\325D\"\210\326H\321\261\210\202\252\211\203\251\211@\331@!\232\203\242\327\330A\321\261\210
A\266\202\202\212\210\210
A\266\202\202?\210\303
!>\204\302\304\305\306D\"\210\211\307H\205\317
?\205\317\332c\207" [cl-struct-soap-xs-complex-type-tags cl-struct-soap-element-tags cl-struct-soap-xs-attribute-tags type-of signal wrong-type-argument soap-xs-complex-type 6 array 7 " xsi:type=\"soapenc:Array\"" " soapenc:arrayType=\"" soap-element-fq-name "[" format "%s" "]" "\"" soap-get-xs-attributes soap-element 1 soap-xs-attribute 4 " " "=\"" symbol-name " xsi:nil=\"true\""] 12 (#$ . 131070)])
#@141 Return a list of elements that are compatible with ELEMENT.
The returned list includes ELEMENT's references and
alternatives.

(fn ELEMENT)
(defalias 'soap-get-candidate-elements #[257 "\301
!>\204\302\303\304D\"\210\211\305H\211\203/\306
C\301!>\204(\302\303\304D\"\210\307H\"\202F\306C\301!>\204B\302\303\304D\"\210\307H\"\207" [cl-struct-soap-xs-element-tags type-of signal wrong-type-argument soap-xs-element 7 append 9] 8 (#$ . 132416)])
#@207 Encode the VALUE according to TYPE.
The data is inserted in the current buffer at the current
position.

This is a specialization of `soap-encode-value' for
`soap-xs-complex-type' objects.

(fn VALUE TYPE)
(defalias 'soap-encode-xs-complex-type #[514 "\302
!>\204\303\304\305D\"\210\211\306H\211\307\267\202>\310\311!\202T
C\312\302!>\2041\303\304\305D\"\210\313H\211\203T\211B\262\302
!>\204L\303\304\305D\"\210\211\313H\262
\2024\210
\211\203\220\211@\302
!>\204k\303\304\305D\"\210\211\314H\211\203\210\211@\211\235\204\201\315C\"\262
A\266\202\202n\210
A\266\202\202V\210\211\211\2057\211@\3162/\317\320!\211\203>
\211@\302
!	>\204\265\303\304\321D\"\210\211\322H\211\203\346\323
!\211\203\341\211@\211@\232\203\332T\262\324
A\"\210
A\266\202\202\301\266\2026
\302\n!>\204\367\303\304\305\fD\"\210	\306H\203
`\324\f\"\210\211`\232\204
T\262\210\2026
\n\211\2035
\211@`\324\"\210\211`\232\204-
T\262\210
A\266\202\202
\210\210
A\266\202\202\240\210\302!>\204P
\303\304\305	D\"\210\306H\325!\302!	>\204g
\303\304\321D\"\210\313H\302!	>\204z
\303\304\321D\"\210\322H\206\226
\211\205\226
\302
!	>\204\223
\303\304\321D\"\210\211\322H\326=\203\251
\317V\203\251
\327\316\330\"\202*\326=\204\355
\317U\203\355
\302!	>\204\306
\303\304\321D\"\210\331H\204\355
\302!>\203\355
\332!\204\355
\333\fD\334\335\336\337#\340#\266\202\202*\322V\205*\302!	>\204\303\304\321D\"\210\306H?\205*\302!>\205*\341!?\205*\342\fD\334\335\336\337#\340#\266\202\266\204\262
0\210
A\266\202\202\222\262
\266\202\202T\310\343\302!>\204P\303\304\305D\"\210\306H\"\207" [cl-struct-soap-xs-complex-type-tags cl-struct-soap-xs-element-tags type-of signal wrong-type-argument soap-xs-complex-type 6 #s(hash-table size 5 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (array 24 sequence 30 choice 30 all 30 nil 30)) error "Arrays of type soap-encode-xs-complex-type are handled elsewhere" nil 7 8 append done 0 soap-get-candidate-elements soap-xs-element 1 intern soap-encode-value soap-xs-element-type choice throw t 5 soap-xs-complex-type-optional-p "While encoding %s: missing non-nillable slot %s" display-warning soap-client apply format :warning soap-xs-complex-type-multiple-p "While encoding %s: expected single, found multiple elements for slot %s" "Don't know how to encode complex type: %s"] 20 (#$ . 132884)])
#@187 Return the children of NODE named CHILD-NAME.
This is the same as `xml-get-children1', but NODE's local
namespace is used to resolve the children's namespace tags.

(fn NODE CHILD-NAME)
(defalias 'soap-xml-get-children-fq #[514 "\303\211AA\262
\211\203N\211@\211:\203G\304\"\211@\206	
A@\206#\n\3058\30618\307\211@\262
!0\202:\210\303\232+\262
\203G\211B\262
A\266\202\202\210\211\237\207" [soap-local-xmlns soap-default-xmlns soap-target-xmlns nil soap-extract-xmlns 2 (error) soap-l2fq] 10 (#$ . 135330)])
#@128 Return ELEMENT's fully-qualified name using WSDL's alias table.
Return nil if ELEMENT does not have a name.

(fn ELEMENT WSDL)
(defalias 'soap-xs-element-get-fq-name #[514 "\301
!\302\303!>\204\304\305\306D\"\210\307H\"A\211\2053\211\303!>\204/\304\305\306D\"\210\310HB\207" [cl-struct-soap-element-tags soap-wsdl-alias-table assoc type-of signal wrong-type-argument soap-element 2 1] 9 (#$ . 135866)])
#@96 Return t if TYPE or any of TYPE's ancestor types is optional.
Return nil otherwise.

(fn TYPE)
(defalias 'soap-xs-complex-type-optional-p #[257 "\211\2055\301
!>\204\302\303\304D\"\210\211\305H\2065\301
!>\2055\306\301!>\2041\302\303\304D\"\210
\307H!\207" [cl-struct-soap-xs-complex-type-tags type-of signal wrong-type-argument soap-xs-complex-type 9 soap-xs-complex-type-optional-p 7] 6 (#$ . 136290)])
#@110 Return t if TYPE or any of TYPE's ancestor types permits multiple elements.
Return nil otherwise.

(fn TYPE)
(defalias 'soap-xs-complex-type-multiple-p #[257 "\211\2055\301
!>\204\302\303\304D\"\210\211\305H\2065\301
!>\2055\306\301!>\2041\302\303\304D\"\210
\307H!\207" [cl-struct-soap-xs-complex-type-tags type-of signal wrong-type-argument soap-xs-complex-type 10 soap-xs-complex-type-multiple-p 7] 6 (#$ . 136714)])
#@79 Return a list of attributes from all ATTRIBUTE-GROUPS.

(fn ATTRIBUTE-GROUPS)
(defalias 'soap-get-xs-attributes-from-groups #[257 "\301
\211\203=\211@\302
!>\204\303\304\305D\"\210\211\306H\307\310!\302!>\204/\303\304\305D\"\210\311H#\262\210
A\266\202\202\210\211\207" [cl-struct-soap-xs-attribute-group-tags nil type-of signal wrong-type-argument soap-xs-attribute-group 5 append soap-get-xs-attributes-from-groups 4] 12 (#$ . 137152)])
#@77 Return a list of all of TYPE's and TYPE's ancestors' attributes.

(fn TYPE)
(defalias 'soap-get-xs-attributes #[257 "\302
!>\205\302
!>\204\303\304\305D\"\210\211\306H\307\302!	>\204*\303\304\310D\"\210\311H\312\302!	>\204>\303\304\310D\"\210\313H!\"
\203P\307
\314!\"\202Q\211\207" [cl-struct-soap-xs-complex-type-tags cl-struct-soap-xs-type-tags type-of signal wrong-type-argument soap-xs-complex-type 7 append soap-xs-type 4 soap-get-xs-attributes-from-groups 5 soap-get-xs-attributes] 9 (#$ . 137613)])
#@87 Use TYPE, a `soap-xs-complex-type', to decode the attributes of NODE.

(fn TYPE NODE)
(defalias 'soap-decode-xs-attributes #[514 "\303\304!\211\203\211@\305
!>\204\306\307\310D\"\210\211\311H\305!>\204+\306\307\310D\"\210
\312H\313!\314\"\305!	>\203S\211\203v
\315\303E\"BB\262\202v\305!\n>\203m\211\203v
\316\"BB\262\202v\317\320\321!#\210\266
A\266\202\202\210\211\207" [cl-struct-soap-xs-attribute-tags cl-struct-soap-xs-basic-type-tags cl-struct-soap-xs-simple-type-tags nil soap-get-xs-attributes type-of signal wrong-type-argument soap-xs-attribute 1 3 intern xml-get-attribute-or-nil soap-decode-xs-basic-type soap-validate-xs-simple-type error "Attribute %s is of type %s which is not a basic or simple type" soap-name-p] 15 (#$ . 138145)])
#@256 Use TYPE, a `soap-xs-complex-type', to decode the contents of NODE.
A LISP value is returned based on the contents of NODE and the
type-info stored in TYPE.

This is a specialization of `soap-decode-type' for
`soap-xs-basic-type' objects.

(fn TYPE NODE)
(defalias 'soap-decode-xs-complex-type #[514 "\303!>\204\304\305\306D\"\210
\307H\211\310\267\202\371
\311\303!>\204)\304\305\306D\"\210\312H\211AA\262
\211\203L\211@\211:\203E\313\"B\262
A\266\202\2022\210
\237\266\202\202\311\303!>\204e\304\305\306D\"\210\312H\211\203s\313
\"\237\262\3142\361
\303!>\204\207\304\305\306D\"\210\315H\211\205\356
\211@\316\303!	>\204\240\304\305\317D\"\210
\320H\321\322\323\n@!\"
\203\311\211\203\277\324	\325\n\"\"\202\314\326	\327!\"\202\314C\330!
\211\203
\211@T\262\331\"\332\333\"\203\364\334\335\332\333\"!\n\336\337$\202\365\313
\"\203
\327	!\340\"BB\262\202
\340
\"\262\266
A\266\202\202\320\210\303\f!>\2041
\304\305\306D\"\210\307H\341=\203O
\342\f!\204O
\316V\203O
\343\314\337\"\210\202\345
\303\f!>\204`
\304\305\306D\"\210\307H\341=\204\245
\316U\203\245
\303!	>\204\200
\304\305\317D\"\210\344H\204\245
\303
!>\203\245
\345
!\204\245
\346C\347\350\351\352#\353#\266\202\345
\320V\203\345
\342\f!\204\345
\303!	>\204\303
\304\305\317D\"\210\307H\204\345
\303
!>\203\345
\342
!\204\345
\354C\347\350\351\352#\353#\266\266
A\266\202\202\212\262
0\210
\237\266\202\202\355\356\303!>\204\304\305\306D\"\210\307H\"\207" [cl-struct-soap-xs-complex-type-tags cl-struct-soap-xs-element-tags soap-current-wsdl type-of signal wrong-type-argument soap-xs-complex-type 6 #s(hash-table size 5 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (array 24 sequence 84 choice 84 all 84 nil 84)) nil 7 soap-decode-type done 8 0 soap-xs-element 1 string-match ":" symbol-name soap-xml-get-children-fq soap-xs-element-get-fq-name xml-get-children intern soap-xs-element-type soap-decode-xs-attributes soap-xml-get-attribute-or-nil1 xsi:type soap-wsdl-get soap-l2fq soap-xs-type-p t append choice soap-xs-complex-type-multiple-p throw 5 soap-xs-complex-type-optional-p "missing non-nillable slot %s" display-warning soap-client apply format :warning "expected single %s slot, found multiple" error "Don't know how to decode complex type: %s"] 21 (#$ . 138941)])
(byte-code "\300\301\302\303\211\211\211\211\211\211\211\211\211\211&\f!\304
\305\306#\210\304
\307\310#\210\304
\311\312#\210\304
\313\314#\210\207" [soap-type-of record soap-xs-complex-type nil put soap-resolve-references soap-resolve-references-for-xs-complex-type soap-attribute-encoder soap-encode-xs-complex-type-attributes soap-encoder soap-encode-xs-complex-type soap-decoder soap-decode-xs-complex-type] 14)
#@71 compiler-macro for inlining `soap-message-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-message-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-message-p (and (memq (type-of cl-x) cl-struct-soap-message-tags) t)) nil] 9 (#$ . 141750)])
(put 'soap-message-p 'compiler-macro 'soap-message-p--cmacro)
#@13 

(fn CL-X)
(defalias 'soap-message-p #[257 "\301
!>\205	\302\207" [cl-struct-soap-message-tags type-of t] 3 (#$ . 142098)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put soap-message-p side-effect-free error-free put soap-message cl-deftype-satisfies] 5)
#@74 compiler-macro for inlining `soap-message-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-message-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-message-name (progn (or (soap-message-p cl-x) (signal 'wrong-type-argument (list 'soap-message cl-x))) (aref cl-x 1))) nil] 9 (#$ . 142382)])
(put 'soap-message-name 'compiler-macro 'soap-message-name--cmacro)
#@62 Access slot "name" of `soap-message' struct CL-X.

(fn CL-X)
(defalias 'soap-message-name #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-message-tags type-of signal wrong-type-argument soap-message 1] 5 (#$ . 142792)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-message-name side-effect-free t] 4)
#@83 compiler-macro for inlining `soap-message-namespace-tag'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-message-namespace-tag--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-message-namespace-tag (progn (or (soap-message-p cl-x) (signal 'wrong-type-argument (list 'soap-message cl-x))) (aref cl-x 2))) nil] 9 (#$ . 143136)])
(put 'soap-message-namespace-tag 'compiler-macro 'soap-message-namespace-tag--cmacro)
#@71 Access slot "namespace-tag" of `soap-message' struct CL-X.

(fn CL-X)
(defalias 'soap-message-namespace-tag #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-message-tags type-of signal wrong-type-argument soap-message 2] 5 (#$ . 143591)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-message-namespace-tag side-effect-free t] 4)
#@75 compiler-macro for inlining `soap-message-parts'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-message-parts--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-message-parts (progn (or (soap-message-p cl-x) (signal 'wrong-type-argument (list 'soap-message cl-x))) (aref cl-x 3))) nil] 9 (#$ . 143962)])
(put 'soap-message-parts 'compiler-macro 'soap-message-parts--cmacro)
#@63 Access slot "parts" of `soap-message' struct CL-X.

(fn CL-X)
(defalias 'soap-message-parts #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-message-tags type-of signal wrong-type-argument soap-message 3] 5 (#$ . 144377)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put soap-message-parts side-effect-free t defalias copy-soap-message copy-sequence] 4)
#@105 compiler-macro for inlining `make-soap-message'.

(fn CL-WHOLE &cl-quote &key NAME NAMESPACE-TAG PARTS)
(defalias 'make-soap-message--cmacro #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\211\203=\211@\304>\203&\211AA\262
\202\305>A@\2034\306\262
\202\307\310@\"\210\202\210\311\312\313\306\306&\207" [plist-member :name :namespace-tag :parts (:name :namespace-tag :parts :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :parts)" cl--defsubst-expand (name namespace-tag parts) (cl-block make-soap-message (record 'soap-message name namespace-tag parts))] 14 (#$ . 144776)])
(put 'make-soap-message 'compiler-macro 'make-soap-message--cmacro)
#@85 Constructor for objects of type `soap-message'.

(fn &key NAME NAMESPACE-TAG PARTS)
(defalias 'make-soap-message #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\211\203=\211@\304>\203&\211AA\262
\202\305>A@\2034\306\262
\202\307\310@\"\210\202\210\311\312$\207" [plist-member :name :namespace-tag :parts (:name :namespace-tag :parts :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :parts)" record soap-message] 9 (#$ . 145497)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-soap-message side-effect-free t cl-struct-define soap-message nil soap-element record ((cl-tag-slot) (name nil) (namespace-tag nil) (parts)) cl-struct-soap-message-tags] 11)
#@73 compiler-macro for inlining `soap-operation-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-operation-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-operation-p (and (memq (type-of cl-x) cl-struct-soap-operation-tags) t)) nil] 9 (#$ . 146269)])
(put 'soap-operation-p 'compiler-macro 'soap-operation-p--cmacro)
#@13 

(fn CL-X)
(defalias 'soap-operation-p #[257 "\301
!>\205	\302\207" [cl-struct-soap-operation-tags type-of t] 3 (#$ . 146629)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put soap-operation-p side-effect-free error-free put soap-operation cl-deftype-satisfies] 5)
#@76 compiler-macro for inlining `soap-operation-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-operation-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-operation-name (progn (or (soap-operation-p cl-x) (signal 'wrong-type-argument (list 'soap-operation cl-x))) (aref cl-x 1))) nil] 9 (#$ . 146921)])
(put 'soap-operation-name 'compiler-macro 'soap-operation-name--cmacro)
#@64 Access slot "name" of `soap-operation' struct CL-X.

(fn CL-X)
(defalias 'soap-operation-name #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-operation-tags type-of signal wrong-type-argument soap-operation 1] 5 (#$ . 147345)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-operation-name side-effect-free t] 4)
#@85 compiler-macro for inlining `soap-operation-namespace-tag'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-operation-namespace-tag--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-operation-namespace-tag (progn (or (soap-operation-p cl-x) (signal 'wrong-type-argument (list 'soap-operation cl-x))) (aref cl-x 2))) nil] 9 (#$ . 147699)])
(put 'soap-operation-namespace-tag 'compiler-macro 'soap-operation-namespace-tag--cmacro)
#@73 Access slot "namespace-tag" of `soap-operation' struct CL-X.

(fn CL-X)
(defalias 'soap-operation-namespace-tag #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-operation-tags type-of signal wrong-type-argument soap-operation 2] 5 (#$ . 148168)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-operation-namespace-tag side-effect-free t] 4)
#@87 compiler-macro for inlining `soap-operation-parameter-order'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-operation-parameter-order--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-operation-parameter-order (progn (or (soap-operation-p cl-x) (signal 'wrong-type-argument (list 'soap-operation cl-x))) (aref cl-x 3))) nil] 9 (#$ . 148549)])
(put 'soap-operation-parameter-order 'compiler-macro 'soap-operation-parameter-order--cmacro)
#@75 Access slot "parameter-order" of `soap-operation' struct CL-X.

(fn CL-X)
(defalias 'soap-operation-parameter-order #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-operation-tags type-of signal wrong-type-argument soap-operation 3] 5 (#$ . 149028)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-operation-parameter-order side-effect-free t] 4)
#@77 compiler-macro for inlining `soap-operation-input'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-operation-input--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-operation-input (progn (or (soap-operation-p cl-x) (signal 'wrong-type-argument (list 'soap-operation cl-x))) (aref cl-x 4))) nil] 9 (#$ . 149415)])
(put 'soap-operation-input 'compiler-macro 'soap-operation-input--cmacro)
#@65 Access slot "input" of `soap-operation' struct CL-X.

(fn CL-X)
(defalias 'soap-operation-input #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-operation-tags type-of signal wrong-type-argument soap-operation 4] 5 (#$ . 149844)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-operation-input side-effect-free t] 4)
#@78 compiler-macro for inlining `soap-operation-output'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-operation-output--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-operation-output (progn (or (soap-operation-p cl-x) (signal 'wrong-type-argument (list 'soap-operation cl-x))) (aref cl-x 5))) nil] 9 (#$ . 150201)])
(put 'soap-operation-output 'compiler-macro 'soap-operation-output--cmacro)
#@66 Access slot "output" of `soap-operation' struct CL-X.

(fn CL-X)
(defalias 'soap-operation-output #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-operation-tags type-of signal wrong-type-argument soap-operation 5] 5 (#$ . 150635)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-operation-output side-effect-free t] 4)
#@78 compiler-macro for inlining `soap-operation-faults'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-operation-faults--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-operation-faults (progn (or (soap-operation-p cl-x) (signal 'wrong-type-argument (list 'soap-operation cl-x))) (aref cl-x 6))) nil] 9 (#$ . 150995)])
(put 'soap-operation-faults 'compiler-macro 'soap-operation-faults--cmacro)
#@66 Access slot "faults" of `soap-operation' struct CL-X.

(fn CL-X)
(defalias 'soap-operation-faults #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-operation-tags type-of signal wrong-type-argument soap-operation 6] 5 (#$ . 151429)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-operation-faults side-effect-free t] 4)
#@84 compiler-macro for inlining `soap-operation-input-action'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-operation-input-action--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-operation-input-action (progn (or (soap-operation-p cl-x) (signal 'wrong-type-argument (list 'soap-operation cl-x))) (aref cl-x 7))) nil] 9 (#$ . 151789)])
(put 'soap-operation-input-action 'compiler-macro 'soap-operation-input-action--cmacro)
#@72 Access slot "input-action" of `soap-operation' struct CL-X.

(fn CL-X)
(defalias 'soap-operation-input-action #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-operation-tags type-of signal wrong-type-argument soap-operation 7] 5 (#$ . 152253)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-operation-input-action side-effect-free t] 4)
#@85 compiler-macro for inlining `soap-operation-output-action'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-operation-output-action--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-operation-output-action (progn (or (soap-operation-p cl-x) (signal 'wrong-type-argument (list 'soap-operation cl-x))) (aref cl-x 8))) nil] 9 (#$ . 152631)])
(put 'soap-operation-output-action 'compiler-macro 'soap-operation-output-action--cmacro)
#@73 Access slot "output-action" of `soap-operation' struct CL-X.

(fn CL-X)
(defalias 'soap-operation-output-action #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-operation-tags type-of signal wrong-type-argument soap-operation 8] 5 (#$ . 153100)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put soap-operation-output-action side-effect-free t defalias copy-soap-operation copy-sequence] 4)
#@164 compiler-macro for inlining `make-soap-operation'.

(fn CL-WHOLE &cl-quote &key NAME NAMESPACE-TAG PARAMETER-ORDER INPUT OUTPUT FAULTS INPUT-ACTION OUTPUT-ACTION)
(defalias 'make-soap-operation--cmacro #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\300\307\"A@\300\310\"A@\211\203`\211@\311>\203H\211AA\262
\2025\312\n>A@\203W\313\262
\2025\314\315@\"\210\2025\210\316\317\320\313
\313







&
\207" [plist-member :name :namespace-tag :parameter-order :input :output :faults :input-action :output-action (:name :namespace-tag :parameter-order :input :output :faults :input-action :output-action :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :parameter-order :input :output :faults :input-action :output-action)" cl--defsubst-expand (name namespace-tag parameter-order input output faults input-action output-action) (cl-block make-soap-operation (record 'soap-operation name namespace-tag parameter-order input output faults input-action output-action))] 24 (#$ . 153535)])
(put 'make-soap-operation 'compiler-macro 'make-soap-operation--cmacro)
#@144 Constructor for objects of type `soap-operation'.

(fn &key NAME NAMESPACE-TAG PARAMETER-ORDER INPUT OUTPUT FAULTS INPUT-ACTION OUTPUT-ACTION)
(defalias 'make-soap-operation #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\300\307\"A@\300\310\"A@\211\203`\211@\311>\203H\211AA\262
\2025\312\n>A@\203W\313\262
\2025\314\315@\"\210\2025\210\316\317								&	\207" [plist-member :name :namespace-tag :parameter-order :input :output :faults :input-action :output-action (:name :namespace-tag :parameter-order :input :output :faults :input-action :output-action :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :parameter-order :input :output :faults :input-action :output-action)" record soap-operation] 19 (#$ . 154707)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-soap-operation side-effect-free t cl-struct-define soap-operation nil soap-element record ((cl-tag-slot) (name nil) (namespace-tag nil) (parameter-order) (input) (output) (faults) (input-action) (output-action)) cl-struct-soap-operation-tags] 11)
#@73 compiler-macro for inlining `soap-port-type-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-port-type-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-port-type-p (and (memq (type-of cl-x) cl-struct-soap-port-type-tags) t)) nil] 9 (#$ . 155887)])
(put 'soap-port-type-p 'compiler-macro 'soap-port-type-p--cmacro)
#@13 

(fn CL-X)
(defalias 'soap-port-type-p #[257 "\301
!>\205	\302\207" [cl-struct-soap-port-type-tags type-of t] 3 (#$ . 156247)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put soap-port-type-p side-effect-free error-free put soap-port-type cl-deftype-satisfies] 5)
#@76 compiler-macro for inlining `soap-port-type-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-port-type-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-port-type-name (progn (or (soap-port-type-p cl-x) (signal 'wrong-type-argument (list 'soap-port-type cl-x))) (aref cl-x 1))) nil] 9 (#$ . 156539)])
(put 'soap-port-type-name 'compiler-macro 'soap-port-type-name--cmacro)
#@64 Access slot "name" of `soap-port-type' struct CL-X.

(fn CL-X)
(defalias 'soap-port-type-name #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-port-type-tags type-of signal wrong-type-argument soap-port-type 1] 5 (#$ . 156963)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-port-type-name side-effect-free t] 4)
#@85 compiler-macro for inlining `soap-port-type-namespace-tag'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-port-type-namespace-tag--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-port-type-namespace-tag (progn (or (soap-port-type-p cl-x) (signal 'wrong-type-argument (list 'soap-port-type cl-x))) (aref cl-x 2))) nil] 9 (#$ . 157317)])
(put 'soap-port-type-namespace-tag 'compiler-macro 'soap-port-type-namespace-tag--cmacro)
#@73 Access slot "namespace-tag" of `soap-port-type' struct CL-X.

(fn CL-X)
(defalias 'soap-port-type-namespace-tag #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-port-type-tags type-of signal wrong-type-argument soap-port-type 2] 5 (#$ . 157786)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-port-type-namespace-tag side-effect-free t] 4)
#@82 compiler-macro for inlining `soap-port-type-operations'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-port-type-operations--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-port-type-operations (progn (or (soap-port-type-p cl-x) (signal 'wrong-type-argument (list 'soap-port-type cl-x))) (aref cl-x 3))) nil] 9 (#$ . 158167)])
(put 'soap-port-type-operations 'compiler-macro 'soap-port-type-operations--cmacro)
#@70 Access slot "operations" of `soap-port-type' struct CL-X.

(fn CL-X)
(defalias 'soap-port-type-operations #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-port-type-tags type-of signal wrong-type-argument soap-port-type 3] 5 (#$ . 158621)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put soap-port-type-operations side-effect-free t defalias copy-soap-port-type copy-sequence] 4)
#@112 compiler-macro for inlining `make-soap-port-type'.

(fn CL-WHOLE &cl-quote &key NAME NAMESPACE-TAG OPERATIONS)
(defalias 'make-soap-port-type--cmacro #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\211\203=\211@\304>\203&\211AA\262
\202\305>A@\2034\306\262
\202\307\310@\"\210\202\210\311\312\313\306\306&\207" [plist-member :name :namespace-tag :operations (:name :namespace-tag :operations :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :operations)" cl--defsubst-expand (name namespace-tag operations) (cl-block make-soap-port-type (record 'soap-port-type name namespace-tag operations))] 14 (#$ . 159047)])
(put 'make-soap-port-type 'compiler-macro 'make-soap-port-type--cmacro)
#@92 Constructor for objects of type `soap-port-type'.

(fn &key NAME NAMESPACE-TAG OPERATIONS)
(defalias 'make-soap-port-type #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\211\203=\211@\304>\203&\211AA\262
\202\305>A@\2034\306\262
\202\307\310@\"\210\202\210\311\312$\207" [plist-member :name :namespace-tag :operations (:name :namespace-tag :operations :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :operations)" record soap-port-type] 9 (#$ . 159810)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-soap-port-type side-effect-free t cl-struct-define soap-port-type nil soap-element record ((cl-tag-slot) (name nil) (namespace-tag nil) (operations)) cl-struct-soap-port-type-tags] 11)
#@79 compiler-macro for inlining `soap-bound-operation-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-bound-operation-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-bound-operation-p (and (memq (type-of cl-x) cl-struct-soap-bound-operation-tags) t)) nil] 9 (#$ . 160619)])
(put 'soap-bound-operation-p 'compiler-macro 'soap-bound-operation-p--cmacro)
#@13 

(fn CL-X)
(defalias 'soap-bound-operation-p #[257 "\301
!>\205	\302\207" [cl-struct-soap-bound-operation-tags type-of t] 3 (#$ . 161015)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put soap-bound-operation-p side-effect-free error-free put soap-bound-operation cl-deftype-satisfies] 5)
#@87 compiler-macro for inlining `soap-bound-operation-operation'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-bound-operation-operation--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-bound-operation-operation (progn (or (soap-bound-operation-p cl-x) (signal 'wrong-type-argument (list 'soap-bound-operation cl-x))) (aref cl-x 1))) nil] 9 (#$ . 161331)])
(put 'soap-bound-operation-operation 'compiler-macro 'soap-bound-operation-operation--cmacro)
#@75 Access slot "operation" of `soap-bound-operation' struct CL-X.

(fn CL-X)
(defalias 'soap-bound-operation-operation #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-bound-operation-tags type-of signal wrong-type-argument soap-bound-operation 1] 5 (#$ . 161822)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-bound-operation-operation side-effect-free t] 4)
#@89 compiler-macro for inlining `soap-bound-operation-soap-action'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-bound-operation-soap-action--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-bound-operation-soap-action (progn (or (soap-bound-operation-p cl-x) (signal 'wrong-type-argument (list 'soap-bound-operation cl-x))) (aref cl-x 2))) nil] 9 (#$ . 162221)])
(put 'soap-bound-operation-soap-action 'compiler-macro 'soap-bound-operation-soap-action--cmacro)
#@77 Access slot "soap-action" of `soap-bound-operation' struct CL-X.

(fn CL-X)
(defalias 'soap-bound-operation-soap-action #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-bound-operation-tags type-of signal wrong-type-argument soap-bound-operation 2] 5 (#$ . 162722)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-bound-operation-soap-action side-effect-free t] 4)
#@90 compiler-macro for inlining `soap-bound-operation-soap-headers'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-bound-operation-soap-headers--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-bound-operation-soap-headers (progn (or (soap-bound-operation-p cl-x) (signal 'wrong-type-argument (list 'soap-bound-operation cl-x))) (aref cl-x 3))) nil] 9 (#$ . 163127)])
(put 'soap-bound-operation-soap-headers 'compiler-macro 'soap-bound-operation-soap-headers--cmacro)
#@78 Access slot "soap-headers" of `soap-bound-operation' struct CL-X.

(fn CL-X)
(defalias 'soap-bound-operation-soap-headers #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-bound-operation-tags type-of signal wrong-type-argument soap-bound-operation 3] 5 (#$ . 163633)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-bound-operation-soap-headers side-effect-free t] 4)
#@87 compiler-macro for inlining `soap-bound-operation-soap-body'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-bound-operation-soap-body--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-bound-operation-soap-body (progn (or (soap-bound-operation-p cl-x) (signal 'wrong-type-argument (list 'soap-bound-operation cl-x))) (aref cl-x 4))) nil] 9 (#$ . 164041)])
(put 'soap-bound-operation-soap-body 'compiler-macro 'soap-bound-operation-soap-body--cmacro)
#@75 Access slot "soap-body" of `soap-bound-operation' struct CL-X.

(fn CL-X)
(defalias 'soap-bound-operation-soap-body #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-bound-operation-tags type-of signal wrong-type-argument soap-bound-operation 4] 5 (#$ . 164532)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-bound-operation-soap-body side-effect-free t] 4)
#@81 compiler-macro for inlining `soap-bound-operation-use'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-bound-operation-use--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-bound-operation-use (progn (or (soap-bound-operation-p cl-x) (signal 'wrong-type-argument (list 'soap-bound-operation cl-x))) (aref cl-x 5))) nil] 9 (#$ . 164931)])
(put 'soap-bound-operation-use 'compiler-macro 'soap-bound-operation-use--cmacro)
#@69 Access slot "use" of `soap-bound-operation' struct CL-X.

(fn CL-X)
(defalias 'soap-bound-operation-use #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-bound-operation-tags type-of signal wrong-type-argument soap-bound-operation 5] 5 (#$ . 165392)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put soap-bound-operation-use side-effect-free t defalias copy-soap-bound-operation copy-sequence] 4)
#@137 compiler-macro for inlining `make-soap-bound-operation'.

(fn CL-WHOLE &cl-quote &key OPERATION SOAP-ACTION SOAP-HEADERS SOAP-BODY USE)
(defalias 'make-soap-bound-operation--cmacro #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\211\203J\211@\306>\2032\211AA\262
\202\307>A@\203A\310\262
\202\311\312@\"\210\202\210\313\314\315\310\n\310\n\n\n\n\n&\n\207" [plist-member :operation :soap-action :soap-headers :soap-body :use (:operation :soap-action :soap-headers :soap-body :use :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:operation :soap-action :soap-headers :soap-body :use)" cl--defsubst-expand (operation soap-action soap-headers soap-body use) (cl-block make-soap-bound-operation (record 'soap-bound-operation operation soap-action soap-headers soap-body use))] 18 (#$ . 165833)])
(put 'make-soap-bound-operation 'compiler-macro 'make-soap-bound-operation--cmacro)
#@117 Constructor for objects of type `soap-bound-operation'.

(fn &key OPERATION SOAP-ACTION SOAP-HEADERS SOAP-BODY USE)
(defalias 'make-soap-bound-operation #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\211\203J\211@\306>\2032\211AA\262
\202\307>A@\203A\310\262
\202\311\312@\"\210\202\210\313\314&\207" [plist-member :operation :soap-action :soap-headers :soap-body :use (:operation :soap-action :soap-headers :soap-body :use :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:operation :soap-action :soap-headers :soap-body :use)" record soap-bound-operation] 13 (#$ . 166791)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-soap-bound-operation side-effect-free t cl-struct-define soap-bound-operation nil cl-structure-object record ((cl-tag-slot) (operation) (soap-action) (soap-headers) (soap-body) (use)) cl-struct-soap-bound-operation-tags] 11)
#@71 compiler-macro for inlining `soap-binding-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-binding-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-binding-p (and (memq (type-of cl-x) cl-struct-soap-binding-tags) t)) nil] 9 (#$ . 167776)])
(put 'soap-binding-p 'compiler-macro 'soap-binding-p--cmacro)
#@13 

(fn CL-X)
(defalias 'soap-binding-p #[257 "\301
!>\205	\302\207" [cl-struct-soap-binding-tags type-of t] 3 (#$ . 168124)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put soap-binding-p side-effect-free error-free put soap-binding cl-deftype-satisfies] 5)
#@74 compiler-macro for inlining `soap-binding-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-binding-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-binding-name (progn (or (soap-binding-p cl-x) (signal 'wrong-type-argument (list 'soap-binding cl-x))) (aref cl-x 1))) nil] 9 (#$ . 168408)])
(put 'soap-binding-name 'compiler-macro 'soap-binding-name--cmacro)
#@62 Access slot "name" of `soap-binding' struct CL-X.

(fn CL-X)
(defalias 'soap-binding-name #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-binding-tags type-of signal wrong-type-argument soap-binding 1] 5 (#$ . 168818)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-binding-name side-effect-free t] 4)
#@83 compiler-macro for inlining `soap-binding-namespace-tag'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-binding-namespace-tag--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-binding-namespace-tag (progn (or (soap-binding-p cl-x) (signal 'wrong-type-argument (list 'soap-binding cl-x))) (aref cl-x 2))) nil] 9 (#$ . 169162)])
(put 'soap-binding-namespace-tag 'compiler-macro 'soap-binding-namespace-tag--cmacro)
#@71 Access slot "namespace-tag" of `soap-binding' struct CL-X.

(fn CL-X)
(defalias 'soap-binding-namespace-tag #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-binding-tags type-of signal wrong-type-argument soap-binding 2] 5 (#$ . 169617)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-binding-namespace-tag side-effect-free t] 4)
#@79 compiler-macro for inlining `soap-binding-port-type'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-binding-port-type--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-binding-port-type (progn (or (soap-binding-p cl-x) (signal 'wrong-type-argument (list 'soap-binding cl-x))) (aref cl-x 3))) nil] 9 (#$ . 169988)])
(put 'soap-binding-port-type 'compiler-macro 'soap-binding-port-type--cmacro)
#@67 Access slot "port-type" of `soap-binding' struct CL-X.

(fn CL-X)
(defalias 'soap-binding-port-type #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-binding-tags type-of signal wrong-type-argument soap-binding 3] 5 (#$ . 170423)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-binding-port-type side-effect-free t] 4)
#@80 compiler-macro for inlining `soap-binding-operations'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-binding-operations--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-binding-operations (progn (or (soap-binding-p cl-x) (signal 'wrong-type-argument (list 'soap-binding cl-x))) (aref cl-x 4))) nil] 9 (#$ . 170782)])
(put 'soap-binding-operations 'compiler-macro 'soap-binding-operations--cmacro)
#@68 Access slot "operations" of `soap-binding' struct CL-X.

(fn CL-X)
(defalias 'soap-binding-operations #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-binding-tags type-of signal wrong-type-argument soap-binding 4] 5 (#$ . 171222)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put soap-binding-operations side-effect-free t defalias copy-soap-binding copy-sequence] 4)
#@120 compiler-macro for inlining `make-soap-binding'.

(fn CL-WHOLE &cl-quote &key NAME NAMESPACE-TAG PORT-TYPE OPERATIONS)
(defalias 'make-soap-binding--cmacro #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"\206\305A@\211\203H\211@\306>\2030\211AA\262
\202\307>A@\203?\310\262
\202\311\312@\"\210\202\210\313\314\315\310	\310				&	\207" [plist-member :name :namespace-tag :port-type :operations (nil (make-hash-table :test 'equal)) (:name :namespace-tag :port-type :operations :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :port-type :operations)" cl--defsubst-expand (name namespace-tag port-type operations) (cl-block make-soap-binding (record 'soap-binding name namespace-tag port-type operations))] 16 (#$ . 171636)])
(put 'make-soap-binding 'compiler-macro 'make-soap-binding--cmacro)
#@100 Constructor for objects of type `soap-binding'.

(fn &key NAME NAMESPACE-TAG PORT-TYPE OPERATIONS)
(defalias 'make-soap-binding #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"\206\305\306\307\310\"DA@\211\203M\211@\311>\2035\211AA\262
\202\"\312>A@\203D\305\262
\202\"\313\314@\"\210\202\"\210\315\316%\207" [plist-member :name :namespace-tag :port-type :operations nil make-hash-table :test equal (:name :namespace-tag :port-type :operations :allow-other-keys) :allow-other-keys error "Keyword argument %s not one of (:name :namespace-tag :port-type :operations)" record soap-binding] 11 (#$ . 172514)])
(cl-struct-define 'soap-binding nil 'soap-element 'record nil '((cl-tag-slot) (name nil) (namespace-tag nil) (port-type) (operations (make-hash-table :test 'equal) :readonly t)) 'cl-struct-soap-binding-tags 'soap-binding t)
#@68 compiler-macro for inlining `soap-port-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-port-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-port-p (and (memq (type-of cl-x) cl-struct-soap-port-tags) t)) nil] 9 (#$ . 173375)])
(put 'soap-port-p 'compiler-macro 'soap-port-p--cmacro)
#@13 

(fn CL-X)
(defalias 'soap-port-p #[257 "\301
!>\205	\302\207" [cl-struct-soap-port-tags type-of t] 3 (#$ . 173705)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put soap-port-p side-effect-free error-free put soap-port cl-deftype-satisfies] 5)
#@71 compiler-macro for inlining `soap-port-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-port-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-port-name (progn (or (soap-port-p cl-x) (signal 'wrong-type-argument (list 'soap-port cl-x))) (aref cl-x 1))) nil] 9 (#$ . 173977)])
(put 'soap-port-name 'compiler-macro 'soap-port-name--cmacro)
#@59 Access slot "name" of `soap-port' struct CL-X.

(fn CL-X)
(defalias 'soap-port-name #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-port-tags type-of signal wrong-type-argument soap-port 1] 5 (#$ . 174366)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-port-name side-effect-free t] 4)
#@80 compiler-macro for inlining `soap-port-namespace-tag'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-port-namespace-tag--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-port-namespace-tag (progn (or (soap-port-p cl-x) (signal 'wrong-type-argument (list 'soap-port cl-x))) (aref cl-x 2))) nil] 9 (#$ . 174695)])
(put 'soap-port-namespace-tag 'compiler-macro 'soap-port-namespace-tag--cmacro)
#@68 Access slot "namespace-tag" of `soap-port' struct CL-X.

(fn CL-X)
(defalias 'soap-port-namespace-tag #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-port-tags type-of signal wrong-type-argument soap-port 2] 5 (#$ . 175129)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-port-namespace-tag side-effect-free t] 4)
#@78 compiler-macro for inlining `soap-port-service-url'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-port-service-url--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-port-service-url (progn (or (soap-port-p cl-x) (signal 'wrong-type-argument (list 'soap-port cl-x))) (aref cl-x 3))) nil] 9 (#$ . 175485)])
(put 'soap-port-service-url 'compiler-macro 'soap-port-service-url--cmacro)
#@66 Access slot "service-url" of `soap-port' struct CL-X.

(fn CL-X)
(defalias 'soap-port-service-url #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-port-tags type-of signal wrong-type-argument soap-port 3] 5 (#$ . 175909)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-port-service-url side-effect-free t] 4)
#@74 compiler-macro for inlining `soap-port-binding'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-port-binding--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-port-binding (progn (or (soap-port-p cl-x) (signal 'wrong-type-argument (list 'soap-port cl-x))) (aref cl-x 4))) nil] 9 (#$ . 176259)])
(put 'soap-port-binding 'compiler-macro 'soap-port-binding--cmacro)
#@62 Access slot "binding" of `soap-port' struct CL-X.

(fn CL-X)
(defalias 'soap-port-binding #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-port-tags type-of signal wrong-type-argument soap-port 4] 5 (#$ . 176663)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put soap-port-binding side-effect-free t defalias copy-soap-port copy-sequence] 4)
#@116 compiler-macro for inlining `make-soap-port'.

(fn CL-WHOLE &cl-quote &key NAME NAMESPACE-TAG SERVICE-URL BINDING)
(defalias 'make-soap-port--cmacro #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\211\203D\211@\305>\203,\211AA\262
\202\306>A@\203;\307\262
\202\310\311@\"\210\202\210\312\313\314\307	\307				&	\207" [plist-member :name :namespace-tag :service-url :binding (:name :namespace-tag :service-url :binding :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :service-url :binding)" cl--defsubst-expand (name namespace-tag service-url binding) (cl-block make-soap-port (record 'soap-port name namespace-tag service-url binding))] 16 (#$ . 177050)])
(put 'make-soap-port 'compiler-macro 'make-soap-port--cmacro)
#@96 Constructor for objects of type `soap-port'.

(fn &key NAME NAMESPACE-TAG SERVICE-URL BINDING)
(defalias 'make-soap-port #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\211\203D\211@\305>\203,\211AA\262
\202\306>A@\203;\307\262
\202\310\311@\"\210\202\210\312\313%\207" [plist-member :name :namespace-tag :service-url :binding (:name :namespace-tag :service-url :binding :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :service-url :binding)" record soap-port] 11 (#$ . 177856)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-soap-port side-effect-free t cl-struct-define soap-port nil soap-element record ((cl-tag-slot) (name nil) (namespace-tag nil) (service-url) (binding)) cl-struct-soap-port-tags] 11)
#@68 compiler-macro for inlining `soap-wsdl-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-wsdl-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-wsdl-p (and (memq (type-of cl-x) cl-struct-soap-wsdl-tags) t)) nil] 9 (#$ . 178701)])
(put 'soap-wsdl-p 'compiler-macro 'soap-wsdl-p--cmacro)
#@13 

(fn CL-X)
(defalias 'soap-wsdl-p #[257 "\301
!>\205	\302\207" [cl-struct-soap-wsdl-tags type-of t] 3 (#$ . 179031)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put soap-wsdl-p side-effect-free error-free put soap-wsdl cl-deftype-satisfies] 5)
#@73 compiler-macro for inlining `soap-wsdl-origin'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-wsdl-origin--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-wsdl-origin (progn (or (soap-wsdl-p cl-x) (signal 'wrong-type-argument (list 'soap-wsdl cl-x))) (aref cl-x 1))) nil] 9 (#$ . 179303)])
(put 'soap-wsdl-origin 'compiler-macro 'soap-wsdl-origin--cmacro)
#@61 Access slot "origin" of `soap-wsdl' struct CL-X.

(fn CL-X)
(defalias 'soap-wsdl-origin #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-wsdl-tags type-of signal wrong-type-argument soap-wsdl 1] 5 (#$ . 179702)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-wsdl-origin side-effect-free t] 4)
#@79 compiler-macro for inlining `soap-wsdl-current-file'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-wsdl-current-file--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-wsdl-current-file (progn (or (soap-wsdl-p cl-x) (signal 'wrong-type-argument (list 'soap-wsdl cl-x))) (aref cl-x 2))) nil] 9 (#$ . 180037)])
(put 'soap-wsdl-current-file 'compiler-macro 'soap-wsdl-current-file--cmacro)
#@67 Access slot "current-file" of `soap-wsdl' struct CL-X.

(fn CL-X)
(defalias 'soap-wsdl-current-file #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-wsdl-tags type-of signal wrong-type-argument soap-wsdl 2] 5 (#$ . 180466)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-wsdl-current-file side-effect-free t] 4)
#@84 compiler-macro for inlining `soap-wsdl-xmlschema-imports'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-wsdl-xmlschema-imports--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-wsdl-xmlschema-imports (progn (or (soap-wsdl-p cl-x) (signal 'wrong-type-argument (list 'soap-wsdl cl-x))) (aref cl-x 3))) nil] 9 (#$ . 180819)])
(put 'soap-wsdl-xmlschema-imports 'compiler-macro 'soap-wsdl-xmlschema-imports--cmacro)
#@72 Access slot "xmlschema-imports" of `soap-wsdl' struct CL-X.

(fn CL-X)
(defalias 'soap-wsdl-xmlschema-imports #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-wsdl-tags type-of signal wrong-type-argument soap-wsdl 3] 5 (#$ . 181273)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-wsdl-xmlschema-imports side-effect-free t] 4)
#@72 compiler-macro for inlining `soap-wsdl-ports'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-wsdl-ports--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-wsdl-ports (progn (or (soap-wsdl-p cl-x) (signal 'wrong-type-argument (list 'soap-wsdl cl-x))) (aref cl-x 4))) nil] 9 (#$ . 181641)])
(put 'soap-wsdl-ports 'compiler-macro 'soap-wsdl-ports--cmacro)
#@60 Access slot "ports" of `soap-wsdl' struct CL-X.

(fn CL-X)
(defalias 'soap-wsdl-ports #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-wsdl-tags type-of signal wrong-type-argument soap-wsdl 4] 5 (#$ . 182035)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-wsdl-ports side-effect-free t] 4)
#@78 compiler-macro for inlining `soap-wsdl-alias-table'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-wsdl-alias-table--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-wsdl-alias-table (progn (or (soap-wsdl-p cl-x) (signal 'wrong-type-argument (list 'soap-wsdl cl-x))) (aref cl-x 5))) nil] 9 (#$ . 182367)])
(put 'soap-wsdl-alias-table 'compiler-macro 'soap-wsdl-alias-table--cmacro)
#@66 Access slot "alias-table" of `soap-wsdl' struct CL-X.

(fn CL-X)
(defalias 'soap-wsdl-alias-table #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-wsdl-tags type-of signal wrong-type-argument soap-wsdl 5] 5 (#$ . 182791)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-wsdl-alias-table side-effect-free t] 4)
#@77 compiler-macro for inlining `soap-wsdl-namespaces'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-wsdl-namespaces--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-wsdl-namespaces (progn (or (soap-wsdl-p cl-x) (signal 'wrong-type-argument (list 'soap-wsdl cl-x))) (aref cl-x 6))) nil] 9 (#$ . 183141)])
(put 'soap-wsdl-namespaces 'compiler-macro 'soap-wsdl-namespaces--cmacro)
#@65 Access slot "namespaces" of `soap-wsdl' struct CL-X.

(fn CL-X)
(defalias 'soap-wsdl-namespaces #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-wsdl-tags type-of signal wrong-type-argument soap-wsdl 6] 5 (#$ . 183560)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put soap-wsdl-namespaces side-effect-free t defalias soap-copy-wsdl copy-sequence] 4)
#@145 compiler-macro for inlining `soap-make-wsdl^'.

(fn CL-WHOLE &cl-quote &key ORIGIN CURRENT-FILE XMLSCHEMA-IMPORTS PORTS ALIAS-TABLE NAMESPACES)
(defalias 'soap-make-wsdl^--cmacro #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\211\203R\211@\307>\203:\211AA\262
\202'\310>A@\203I\311\262
\202'\312\313@\"\210\202'\210\314\315\316\311\311&\207" [plist-member :origin :current-file :xmlschema-imports :ports :alias-table :namespaces (:origin :current-file :xmlschema-imports :ports :alias-table :namespaces :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:origin :current-file :xmlschema-imports :ports :alias-table :namespaces)" cl--defsubst-expand (origin current-file xmlschema-imports ports alias-table namespaces) (cl-block soap-make-wsdl^ (record 'soap-wsdl origin current-file xmlschema-imports ports alias-table namespaces))] 20 (#$ . 183956)])
(put 'soap-make-wsdl^ 'compiler-macro 'soap-make-wsdl^--cmacro)
#@124 Constructor for objects of type `soap-wsdl'.

(fn &key ORIGIN CURRENT-FILE XMLSCHEMA-IMPORTS PORTS ALIAS-TABLE NAMESPACES)
(defalias 'soap-make-wsdl^ #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\211\203R\211@\307>\203:\211AA\262
\202'\310>A@\203I\311\262
\202'\312\313@\"\210\202'\210\314\315&\207" [plist-member :origin :current-file :xmlschema-imports :ports :alias-table :namespaces (:origin :current-file :xmlschema-imports :ports :alias-table :namespaces :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:origin :current-file :xmlschema-imports :ports :alias-table :namespaces)" record soap-wsdl] 15 (#$ . 184974)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put soap-make-wsdl^ side-effect-free t cl-struct-define soap-wsdl nil cl-structure-object record ((cl-tag-slot) (origin) (current-file) (xmlschema-imports) (ports) (alias-table) (namespaces)) cl-struct-soap-wsdl-tags] 11)
#@81 Create a new WSDL document, loaded from ORIGIN, and initialize it.

(fn ORIGIN)
(defalias 'soap-make-wsdl #[257 "\301\302\303\211\211\211\211&\304\305\306\"\307
\"\210\310\306\311!>\204$\312\313\314D\"\210\315H#\266\304\316\317\"\307
\"\210\310\317\311!>\204E\312\313\314D\"\210\315H#\266\211\207" [cl-struct-soap-namespace-tags record soap-wsdl nil soap-make-xs-basic-types "http://www.w3.org/2001/XMLSchema" "xsd" soap-wsdl-add-namespace soap-wsdl-add-alias type-of signal wrong-type-argument soap-namespace 1 "http://schemas.xmlsoap.org/soap/encoding/" "soapenc"] 9 (#$ . 186007)])
#@76 Add a namespace ALIAS for NAME to the WSDL document.

(fn ALIAS NAME WSDL)
(defalias 'soap-wsdl-add-alias #[771 "\301\302!>\204\303\304\305D\"\210\306H\"\211\203L\211A\232?\205k\307\310A$\210B\302!>\204<\303\304\305D\"\210\211\306\306HBI\262
\262
\202kB\302!>\204^\303\304\305D\"\210\211\306\306HBI\262
\262
\207" [cl-struct-soap-wsdl-tags assoc type-of signal wrong-type-argument soap-wsdl 5 warn "Redefining alias %s from %s to %s"] 11 (#$ . 186616)])
#@64 Find a namespace by NAME in the WSDL document.

(fn NAME WSDL)
(defalias 'soap-wsdl-find-namespace #[514 "\3022B\303
!>\204\304\305\306D\"\210\211\307H\211\205?\211@\303!	>\204,\304\305\310D\"\210
\311H\232\2038\312\302\"\210
A\266\202\202\262
0\207" [cl-struct-soap-wsdl-tags cl-struct-soap-namespace-tags found type-of signal wrong-type-argument soap-wsdl 6 soap-namespace 1 throw] 9 (#$ . 187109)])
#@151 Add the namespace NS to the WSDL document.
If a namespace by this name already exists in WSDL, individual
elements will be added to it.

(fn NS WSDL)
(defalias 'soap-wsdl-add-namespace #[514 "\302\303!>\204\304\305\306D\"\210\307H\"\211\203>\310\311\312\313\314\315!\316\"\317\320%\303!>\2047\304\305\306D\"\210\321H\"\202X\303!	>\204M\304\305\322D\"\210
\211\323\323HBI\262
\207" [cl-struct-soap-namespace-tags cl-struct-soap-wsdl-tags soap-wsdl-find-namespace type-of signal wrong-type-argument soap-namespace 1 maphash make-byte-code 514 "\211\211\205\211@\301
\300\"\210
A\266\202\202
\207" vconcat vector [soap-namespace-put] 7 "\n\n(fn KEY VALUE)" 2 soap-wsdl 6] 10 (#$ . 187532)])
#@562 Retrieve element NAME from the WSDL document.

PREDICATE is used to differentiate between elements when NAME
refers to multiple elements.  A typical value for this would be a
structure predicate for the type of element you want to retrieve.
For example, to retrieve a message named "foo" when other
elements named "foo" exist in the WSDL you could use:

  (soap-wsdl-get "foo" WSDL \='soap-message-p)

If USE-LOCAL-ALIAS-TABLE is not nil, `soap-local-xmlns' will be
used to resolve the namespace alias.

(fn NAME WSDL &optional PREDICATE USE-LOCAL-ALIAS-TABLE)
(defalias 'soap-wsdl-get #[1026 "\303!>\204\304\305\306D\"\210\307H\310\211\2119\203!\311!\262\203+\312	\"\262:\203WA\262
9\203@\311!\262\313@\"\262\204\232\314\315	#\210\202\232\316\317	\"\203\224\320\321	\"\262\320\322	\"\323
\"A\211\204|\314\324#\210\313
\n\"\262\204\217\314\325$\210\266\202\232\314\326	\"\210\327\205\257\330\331\332\333\334
!\335\"\336\337%#\262
\211\204\274\314\340	\"\210\303
!\n>\203\337\341\303!\n>\204\324\304\305\342D\"\210
\336H#\202\340\211\207" [cl-struct-soap-wsdl-tags soap-local-xmlns cl-struct-soap-namespace-link-tags type-of signal wrong-type-argument soap-wsdl 5 nil symbol-name append soap-wsdl-find-namespace error "Soap-wsdl-get(%s): unknown namespace: %s" string-match "^\\(.*\\):\\(.*\\)$" match-string 2 1 assoc "Soap-wsdl-get(%s): cannot find namespace alias %s" "Soap-wsdl-get(%s): unknown namespace %s, referenced as %s" "Soap-wsdl-get(%s): bad name" soap-namespace-get make-byte-code 257 "\301
!\206	\300
!\207" vconcat vector [soap-namespace-link-p] 3 "\n\n(fn E)" "Soap-wsdl-get(%s): cannot find element" soap-wsdl-get soap-namespace-link] 17 (#$ . 188252)])
#@116 Parse a schema NODE, placing the results in WSDL.
Return a SOAP-NAMESPACE containing the elements.

(fn NODE WSDL)
(defalias 'soap-parse-schema #[514 "\304\"\211@\206\n	
A@\206\n\3058\306\211@\262
!\307=\2042\310\311\312\313\306\211@\262
!C$\210\314\315\316!\"\211AA\262
\211\203\275\211@\211;\204\266\306
\211@\262
!\211\317\267\202\265\320\321\"\206a\320\322\"\211\203\202\323!>\204v\324\325\326	D\"\210\211\327\327HBI\266\210\202\265\330\331!\"\210\202\265\330\332!\"\210\202\265\330\333!\"\210\202\265\330\334!\"\210\202\265\330\335!\"\210\210
A\266\202\202>\210\211\262
+\207" [soap-local-xmlns soap-default-xmlns soap-target-xmlns cl-struct-soap-wsdl-tags soap-extract-xmlns 2 soap-l2wk xsd:schema cl--assertion-failed (eq (soap-l2wk (xml-node-name node)) 'xsd:schema) "expecting an xsd:schema node, got %s" nil make-soap-namespace :name soap-get-target-namespace #s(hash-table size 7 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (xsd:import 86 xsd:element 134 xsd:attribute 144 xsd:attributeGroup 154 xsd:simpleType 164 xsd:complexType 174 xsd:group 174)) xml-get-attribute-or-nil schemaLocation location type-of signal wrong-type-argument soap-wsdl 3 soap-namespace-put soap-xs-parse-element soap-xs-parse-attribute soap-xs-parse-attribute-group soap-xs-parse-simple-type soap-xs-parse-complex-type] 14 (#$ . 190005)])
#@256 Replace names in ELEMENT with the referenced objects in the WSDL.
This is a generic function which invokes a specific resolver
function depending on the type of the ELEMENT.

If ELEMENT has no resolver function, it is silently ignored.

(fn ELEMENT WSDL)
(defalias 'soap-resolve-references #[514 "\300!\301N\211\205
\211\"\207" [soap-type-of soap-resolve-references] 6 (#$ . 191406)])
#@231 Replace names in MESSAGE with the referenced objects in the WSDL.
This is a generic function, called by `soap-resolve-references',
you should use that function instead.

See also `soap-wsdl-resolve-references'.

(fn MESSAGE WSDL)
(defalias 'soap-resolve-references-for-message #[514 "\302\303!>\204\304\305\306D\"\210\307H\211\203\215\211@\211@
A
;\203'\310!\262\311
!\2038\312
\313#\262
\202}\314
\"\210\303
!	>\204M\304\305\315D\"\210\211\316H\204}\303
!	>\204b\304\305\315D\"\210\211\211\316\303\n!	>\204v\304\305\315\fD\"\210	\316HI\266

BB\262\266
A\266\202\202\210\303!>\204\235\304\305\306D\"\210\211\307\237I\262
\207" [cl-struct-soap-message-tags cl-struct-soap-element-tags nil type-of signal wrong-type-argument soap-message 3 intern soap-name-p soap-wsdl-get #[257 "\302
!>\203\n\303\207\302
!	>\205\303\207" [cl-struct-soap-xs-type-tags cl-struct-soap-xs-element-tags type-of t] 3 "\n\n(fn X)"] soap-resolve-references soap-element 2] 14 (#$ . 191802)])
#@158 Resolve references for an OPERATION type using the WSDL document.
See also `soap-resolve-references' and
`soap-wsdl-resolve-references'

(fn OPERATION WSDL)
(defalias 'soap-resolve-references-for-operation #[514 "\304!>\204\305\306\307D\"\210
\310H\211\203I\311
\304!	>\204(\305\306\312D\"\210\313H\"@\211\203H\304!>\204A\305\306\307D\"\210\211\310I\266\210\210\304!\n>\204Y\305\306\314D\"\210
\315H\316
@A
\203k
\317\232\203u\320\321T\211\262\"\262\322
!\203\234\304!\n>\204\214\305\306\314D\"\210\211\315\323!\324\n\325#BI\266\266\304!\n>\204\255\305\306\314D\"\210
\313H\316
@A
\203\277
\317\232\203\311\320\326T\211\262\"\262\322
!\203\360\304!\n>\204\340\305\306\314D\"\210\211\313\323!\324\n\325#BI\266\266\327\316\304!\n>\204
\305\306\314D\"\210\330H\211\203M
\211@\211@
A
\203

\317\232\203&
\320\331T\211\262\"\262\322
!\203>
\323!\324	\325#BB\262\202D
B\262\266
A\266\202\202
\210\304!\n>\204^
\305\306\314D\"\210\211\330I\266\304!\n>\204t
\305\306\314D\"\210
\332HG\316U\203\346
\304!\n>\204\214
\305\306\314D\"\210
\211\332\333\334\304\211!\n>\204\243
\305\306\314\nD\"\210\315HA!>\204\312
\305\306\335\304\n!\n>\204\302
\305\306\314\fD\"\210	\315HAD\"\210\304!\n>\204\333
\305\306\314	D\"\210\315HA\332H\"I\266\304!\n>\204\365
\305\306\314D\"\210
\211\332\333\336\304!\n>\204\305\306\314	D\"\210\332H\"I\207" [cl-struct-soap-element-tags cl-struct-soap-wsdl-tags cl-struct-soap-operation-tags cl-struct-soap-message-tags type-of signal wrong-type-argument soap-element 2 rassoc soap-wsdl 5 soap-operation 4 0 "" format "in%d" soap-name-p intern soap-wsdl-get soap-message-p "out%d" nil 6 "fault%d" 3 mapcar car soap-message #[257 "\211;\203	\300
!\207\207" [intern] 3 "\n\n(fn P)"]] 14 (#$ . 192817)])
#@153 Resolve references for a BINDING type using the WSDL document.
See also `soap-resolve-references' and
`soap-wsdl-resolve-references'

(fn BINDING WSDL)
(defalias 'soap-resolve-references-for-binding #[514 "\302\303!>\204\304\305\306D\"\210\307H!\203D\303!>\204&\304\305\306D\"\210
\211\307\310\303!>\204;\304\305\306D\"\210\307H\311#I\266\303\211!>\204T\304\305\306D\"\210\307H!	>\204v\304\305\312\303!>\204p\304\305\306D\"\210\307HD\"\210\303!>\204\205\304\305\306D\"\210
\307H\307H\313\314\315\316\317\320\"\321\"\322\323%\303!>\204\252\304\305\306D\"\210\324H\"\207" [cl-struct-soap-binding-tags cl-struct-soap-port-type-tags soap-name-p type-of signal wrong-type-argument soap-binding 3 soap-wsdl-get soap-port-type-p soap-port-type maphash make-byte-code 514 "\303
!\n>\204\304\305\306D\"\210\211\211\307\310\301\311#I\266\312\303!\n>\204*\304\305\306D\"\210
\313H\211\203L\211@\314
@\300\"\315A@!\3168EB\262
A\266\202\202-\210\303!\n>\204\\\304\305\306D\"\210
\211\313\237I\262
\207" vconcat vector [cl-struct-soap-bound-operation-tags type-of signal wrong-type-argument soap-bound-operation 1 soap-namespace-get soap-operation-p nil 3 soap-wsdl-get intern 2] 9 "\n\n(fn K V)" 4] 11 (#$ . 194658)])
#@225 Replace names in PORT with the referenced objects in the WSDL.
This is a generic function, called by `soap-resolve-references',
you should use that function instead.

See also `soap-wsdl-resolve-references'.

(fn PORT WSDL)
(defalias 'soap-resolve-references-for-port #[514 "\301\302!>\204\303\304\305D\"\210\306H!\205D\302!>\204&\303\304\305D\"\210
\211\306\307\302!>\204;\303\304\305D\"\210\306H\310#I\262
\207" [cl-struct-soap-port-tags soap-name-p type-of signal wrong-type-argument soap-port 4 soap-wsdl-get soap-binding-p] 10 (#$ . 195934)])
(byte-code "\300\301\302\303\304\211\211$!\305\306#\210\300\301\302\307\304\211\211\211\211\211\211\211&	!\305\310#\210\300\301\311 !\305\312#\210\300\301\302\313\304\211\211\211%!\305\314#\207" [put soap-type-of record soap-message nil soap-resolve-references soap-resolve-references-for-message soap-operation soap-resolve-references-for-operation make-soap-binding soap-resolve-references-for-binding soap-port soap-resolve-references-for-port] 12)
#@532 Resolve all references inside the WSDL structure.

When the WSDL elements are created from the XML document, they
refer to each other by name.  For example, the ELEMENT-TYPE slot
of an SOAP-ARRAY-TYPE will contain the name of the element and
the user would have to call `soap-wsdl-get' to obtain the actual
element.

After the entire document is loaded, we resolve all these
references to the actual elements they refer to so that at
runtime, we don't have to call `soap-wsdl-get' each time we
traverse an element tree.

(fn WSDL)
(defalias 'soap-wsdl-resolve-references #[257 "\302C\302\303!>\204\304\305\306D\"\210\307H\303!>\204%\304\305\306D\"\210\310H\211\203\255\211@\311\303!	>\204>\304\305\312D\"\210
\313H\"\242\211\204\200\3142\315\316T\211\262\"\262
\317
\"\204L\320
\303!	>\204p\304\305\312D\"\210\313H	#\210\321\314\322\"\210\202L\210\323\324\325\326\327\330\f\f\"\331\"\332\333%\303!	>\204\240\304\305\312D\"\210\334H\"\266
A\266\202\202(\266\207" [cl-struct-soap-wsdl-tags cl-struct-soap-namespace-tags 0 type-of signal wrong-type-argument soap-wsdl 5 6 rassoc soap-namespace 1 done format "ns%d" assoc soap-wsdl-add-alias throw t maphash make-byte-code 514 "\303
!\n>\203\301\211\242T\240\210\304
\300\"\207\211<\205;\211\211\2059\211@\303
!\n>\2032\301\211\242T\240\210\304
\300\"\210
A\266\202\202\262
\207" vconcat vector [cl-struct-soap-element-tags type-of soap-resolve-references] 7 "\n\n(fn NAME ELEMENT)" 2] 15 (#$ . 196960)])
#@63 Error-check and parse the XML contents of the current buffer.
(defalias 'soap-parse-server-response #[0 "\300\301\211\"\211\211@;\203\211@\262
\202\211A@@\262
\302\232\203u\303\304\305\211@;\203.\211@\262
\2024\211A@@\262
#\306\232\203u\303\304\307\211@;\203K\211@\262
\202Q\211A@@\262
#\303\304\305\211@;\203c\211@\262
\202i\211A@@\262
#C\310\211\211\211\211\211\257\262
\211\204}\311\312!\210\211A@@\306\232\204\212\311\313!\210\314\315!r\211q\210\316\304\317\320\321!\322\"\323$\216\324!\210\325ed\"@\326 \210\327!\210*\262
\207" [mm-dissect-buffer t "multipart/related" get-text-property 0 type "text/xml" buffer nil error "Failed to decode response from server" "Server response is not an XML document" generate-new-buffer " *temp*" make-byte-code "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 mm-insert-part xml-parse-region kill-buffer mm-destroy-part] 9 (#$ . 198466)])
#@106 Load an XML document from URL and return it.
The previously parsed URL is read from WSDL.

(fn URL WSDL)
(defalias 'soap-fetch-xml-from-url #[514 "\306\307\"\210\310\311!>\204\312\313\314D\"\210\315H\"\316\317\320\321\322\311!>\2043\312\313\314D\"\210
\211\315I\266\323
!r\211q\210\324V\203N\325\326\"\210\327 )\262
-\207" [cl-struct-soap-wsdl-tags url-http-attempt-keepalives url-mime-charset-string url-package-version url-package-name url-request-method message "Fetching from %s" url-expand-file-name type-of signal wrong-type-argument soap-wsdl 2 "GET" "soap-client.el" "1.0" "utf-8;q=1, iso-8859-1;q=0.5" t url-retrieve-synchronously 299 error "Error retrieving WSDL: %s" soap-parse-server-response url-http-response-status] 8 (#$ . 199400)])
#@109 Load an XML document from FILE and return it.
The previously parsed file is read from WSDL.

(fn FILE WSDL)
(defalias 'soap-fetch-xml-from-file #[514 "\302
!>\204\303\304\305D\"\210\211\306H\307\203\310!\202	\"\302!>\204/\303\304\305D\"\210\211\306I\266\311\312!r\211q\210\313\314\315\316\317!\320\"\306$\216\321!\210\322ed\"@*\262
\207" [cl-struct-soap-wsdl-tags default-directory type-of signal wrong-type-argument soap-wsdl 2 expand-file-name file-name-directory generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] insert-file-contents xml-parse-region] 11 (#$ . 200180)])
#@130 Load an XML document from FILE-OR-URL and return it.
The previously parsed file or URL is read from WSDL.

(fn FILE-OR-URL WSDL)
(defalias 'soap-fetch-xml #[514 "\301
!>\204\302\303\304D\"\210\211\305H\206
\211\203 \306
!\204&\306!\203-\307\"\2021\310\"\207" [cl-struct-soap-wsdl-tags type-of signal wrong-type-argument soap-wsdl 2 file-exists-p soap-fetch-xml-from-file soap-fetch-xml-from-url] 6 (#$ . 200850)])
#@115 Load a document from FILE-OR-URL and return it.
Build on WSDL if it is provided.

(fn FILE-OR-URL &optional WSDL)
(defalias 'soap-load-wsdl #[513 "\211\206\300!\301\"\302\303\"!\210
\207" [soap-make-wsdl soap-fetch-xml soap-wsdl-resolve-references soap-parse-wsdl] 8 (#$ . 201286)])
(defalias 'soap-load-wsdl-from-url 'soap-load-wsdl)
#@39 Assert that NODE is valid.

(fn NODE)
(defalias 'soap-parse-wsdl-phase-validate-node #[257 "\303
\"\211@\206\n	
A@\206\n\3048\305\211@\262
!\211\306=\204,\307\310\311\312C$\210\312\262
+\207" [soap-local-xmlns soap-default-xmlns soap-target-xmlns soap-extract-xmlns 2 soap-l2wk wsdl:definitions cl--assertion-failed (eq node-name 'wsdl:definitions) "expecting wsdl:definitions node, got %s" nil] 8 (#$ . 201634)])
#@66 Fetch and load files imported by NODE into WSDL.

(fn NODE WSDL)
(defalias 'soap-parse-wsdl-phase-fetch-imports #[514 "\303\"\211@\206\n	
A@\206\n\3048\305\306\"\211\2057\211@\307
\310\"\211\203/\311
\"\210\210
A\266\202\202\262
+\207" [soap-local-xmlns soap-default-xmlns soap-target-xmlns soap-extract-xmlns 2 soap-xml-get-children1 wsdl:import xml-get-attribute-or-nil location soap-load-wsdl] 9 (#$ . 202065)])
#@53 Load types found in NODE into WSDL.

(fn NODE WSDL)
(defalias 'soap-parse-wsdl-phase-parse-schema #[514 "\303\"\211@\206\n	
A@\206\n\3048\305\306\"@\211\211AA\262
\211\205c\211@\211:\203\\\303
\"\211@\2067	
A@\206>\n\3048\307\211@\262
!\310=\203Z\311\312\"\"\210+\210
A\266\202\202\"\262
\262
+\207" [soap-local-xmlns soap-default-xmlns soap-target-xmlns soap-extract-xmlns 2 soap-xml-get-children1 wsdl:types soap-l2wk xsd:schema soap-wsdl-add-namespace soap-parse-schema] 11 (#$ . 202502)])
#@74 Fetch and load schema imports defined by NODE into WSDL.

(fn NODE WSDL)
(defalias 'soap-parse-wsdl-phase-fetch-schema #[514 "\304\"\211@\206\n	
A@\206\n\3058\306!>\204&\307\310\311D\"\210
\312H\205Z\306!>\204;\307\310\311D\"\210
\211\312H\211\312AI\210\266\202\242\313
\"\314\315\"\"\266\202+\207" [soap-local-xmlns soap-default-xmlns soap-target-xmlns cl-struct-soap-wsdl-tags soap-extract-xmlns 2 type-of signal wrong-type-argument soap-wsdl 3 soap-fetch-xml soap-wsdl-add-namespace soap-parse-schema] 9 (#$ . 203028)])
#@48 Finish parsing NODE into WSDL.

(fn NODE WSDL)
(defalias 'soap-parse-wsdl-phase-finish-parsing #[514 "\305\"\211@\206\n	
A@\206\n\3068\307\310\311!\"\312\313\"\211\2035\211@\314\315!\"\210
A\266\202\202!\210\312\316\"\211\203g\211@\317
!\314
\"\210\320\321!>\204X\322\323\324D\"\210
\325H\"\266
A\266\202\202:\210\312\326\"\211\203\200\211@\314\327!\"\210
A\266\202\202l\210\312\330\"\211\203
\211@\312
\331\"\211\203\370\211@\211\332\333\"\206\237\334\266\202
\335\333\"\206\253\334\266\202\312\336\"@\211\337\333\"\206\274\334\266\202\262
\340\310\341\342\343\"\344&\314
\n\"\210\321!\f>\204\345\322\323\345
D\"\210\n\211\346\346HBI\266
A\266\202\202\217\210
A\266\202\202\205\210\320
\"\262
+\207" [soap-local-xmlns soap-default-xmlns soap-target-xmlns cl-struct-soap-port-type-tags cl-struct-soap-wsdl-tags soap-extract-xmlns 2 make-soap-namespace :name soap-get-target-namespace soap-xml-get-children1 wsdl:message soap-namespace-put soap-parse-message wsdl:portType soap-parse-port-type soap-wsdl-add-namespace type-of signal wrong-type-argument soap-port-type 3 wsdl:binding soap-parse-binding wsdl:service wsdl:port name xml-get-attribute-or-nil "" binding wsdlsoap:address location make-soap-port :binding soap-l2fq tns :service-url soap-wsdl 4] 18 (#$ . 203585)])
#@81 Construct from NODE a WSDL structure, which is an XML document.

(fn NODE WSDL)
(defalias 'soap-parse-wsdl #[514 "\300!\210\301\"\210\302\"\210\303\"\210\304\"\210\207" [soap-parse-wsdl-phase-validate-node soap-parse-wsdl-phase-fetch-imports soap-parse-wsdl-phase-parse-schema soap-parse-wsdl-phase-fetch-schema soap-parse-wsdl-phase-finish-parsing] 5 (#$ . 204927)])
#@76 Parse NODE as a wsdl:message and return the corresponding type.

(fn NODE)
(defalias 'soap-parse-message #[257 "\301
\211@\262
!\302=\204\303\304\305\306\301\211@\262
!C$\210\307
\310\"\306\311\312\"\211\203n\211@\307
\310\"\307\313\"\307\314\"
\203?\315\316\"\262\211\203L\315
\316\"\262
\202]\317\320\306\306\211\211\211\211\211&\262

BB\262\266
A\266\202\202#\210\321\322\323\237$\207" [soap-target-xmlns soap-l2wk wsdl:message cl--assertion-failed (eq (soap-l2wk (xml-node-name node)) 'wsdl:message) "expecting wsdl:message node, got %s" nil xml-get-attribute-or-nil name soap-xml-get-children1 wsdl:part type element soap-l2fq tns record soap-xs-element make-soap-message :name :parts] 20 (#$ . 205310)])
#@77 Parse NODE as a wsdl:portType and return the corresponding port.

(fn NODE)
(defalias 'soap-parse-port-type #[257 "\303
\211@\262
!\304=\204\305\306\307\310\303\211@\262
!C$\210\311
\312\313\"\206%\314\266\202P\315\316\"\317\320\"\211\203
\211@\321
!\322\323!	>\204J\324\325\326D\"\210
\327H\330#\211\203v\331\323!	>\204d\324\325\326D\"\210\327HC\332\333\334\335#\336#\266\202
\337\"\210\323!\n>\204\213\324\325\340D\"\210
\341H\211\203\233\211
A\262\242\202\242\324\342\343GD\"\344
	#\266\323!\n>\204\271\324\325\340D\"\210
\345H\211\203\311\211
A\262\242\202\320\324\342\346GD\"\344
	#\266\323!\n>\204\347\324\325\340D\"\210
\347H\211\203
\211@\211\211\203\376\211
A\262\242\202
\324\342\350GD\"\344
#\266
A\266\202\202\352\210\266
A\266\202\2021\210\351\316\312\313\"\206+
\314\266\202\352$)\207" [soap-target-xmlns cl-struct-soap-element-tags cl-struct-soap-operation-tags soap-l2wk wsdl:portType cl--assertion-failed (eq (soap-l2wk (xml-node-name node)) 'wsdl:portType) "expecting wsdl:portType node got %s" nil "urn:" name xml-get-attribute-or-nil "" make-soap-namespace :name soap-xml-get-children1 wsdl:operation soap-parse-operation soap-namespace-get type-of signal wrong-type-argument soap-element 1 soap-operation-p "Discarding duplicate operation: %s" display-warning soap-client apply format :warning soap-namespace-put soap-operation 4 wrong-number-of-arguments (name . message) soap-namespace-put-link 5 (name . message) 6 (name . message) make-soap-port-type :operations] 14 (#$ . 206051)])
#@78 Parse NODE as a wsdl:operation and return the corresponding type.

(fn NODE)
(defalias 'soap-parse-operation #[257 "\301
\211@\262
!\302=\204\303\304\305\306\301\211@\262
!C$\210\211\307\310\"\206$\311\266\202\312\313\310\"\2061\311\266\202!\306\211\211\211\211\211AA\262
\211\203\333\211@\211:\203\324\301
\211@\262
!\211\314\267\202\323
\315\310\"\206b\311\266\202\307\310\"\206n\311\266\202\316\317\"
\320\321\"B\262\262\266\202\323
\315\310\"\206\215\311\266\202\307\310\"\206\231\311\266\202\316\317\"
\320\321\"B\262\n\262\266\202\323
\315\310\"\206\270\311\266\202\307\310\"\206\304\311\266\202\211\320\321\"BB\262\266\210
A\266\202\202@\210\322\323\324\325\326\f\327
\330\237\331\332&\207" [soap-target-xmlns soap-l2wk wsdl:operation cl--assertion-failed (eq (soap-l2wk (xml-node-name node)) 'wsdl:operation) "expecting wsdl:operation node, got %s" nil name xml-get-attribute-or-nil "" split-string parameterOrder #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (wsdl:input 88 wsdl:output 131 wsdl:fault 174)) message soap-xml-get-attribute-or-nil1 wsaw:Action soap-l2fq tns make-soap-operation :name :namespace-tag :parameter-order :input :output :faults :input-action :output-action] 25 (#$ . 207630)])
#@76 Parse NODE as a wsdl:binding and return the corresponding type.

(fn NODE)
(defalias 'soap-parse-binding #[257 "\301
\211@\262
!\302=\204\303\304\305\306\301\211@\262
!C$\210\211\307\310\"\206$\311\266\202
\312\310\"\2060\311\266\202\313\314\315\316\317\"$\320\321\"\211\203C
\211@\211\307\310\"\206O\311\266\202\306\211\211\211\320\322\"\211\203m\211@\310
\323\"\262
A\266\202\202Z\210\320\324\"\211\203\324\211@\320
\325\"\211\203\253\211@\316\310\326\"!\310\327\"\310\330\"\203\242
\203\242E\nB\262\n\266
A\266\202\202}\210\320
\331\"@\310
\332\"\262\203\306\333\334\335\306\336#\"\262\310
\330\"\262\210
A\266\202\202s\210\211\204
\320\337\"\211\203
\211@\320
\331\"\211\203\377\211@\206\366\310
\330\"\262
A\266\202\202\350\210
A\266\202\202\336\210\340\341\342\343	\344\n\237\345\346\f\205\"
\334
!&\n\347!>\2045
\350\351\352
D\"\210\n\353H#\266
A\266\202\202?\210\211\262
\207" [cl-struct-soap-binding-tags soap-l2wk wsdl:binding cl--assertion-failed (eq (soap-l2wk (xml-node-name node)) 'wsdl:binding) "expecting wsdl:binding node, got %s" nil name xml-get-attribute-or-nil "" type make-soap-binding :name :port-type soap-l2fq tns soap-xml-get-children1 wsdl:operation wsdlsoap:operation soapAction wsdl:input wsdlsoap:header message part use wsdlsoap:body parts mapcar intern split-string omit-nulls wsdl:output puthash make-soap-bound-operation :operation :soap-action :soap-headers :soap-body :use type-of signal wrong-type-argument soap-binding 4] 25 (#$ . 208953)])
#@136 The list of multi-ref nodes in the current SOAP response.
This is a dynamically bound variable used during decoding the
SOAP response.
(defvar soap-multi-refs nil (#$ . 210509))
#@140 List of decoded multi-ref nodes in the current SOAP response.
This is a dynamically bound variable used during decoding the
SOAP response.
(defvar soap-decoded-multi-refs nil (#$ . 210694))
#@314 Use TYPE (an xsd type) to decode the contents of NODE.

NODE is an XML node, representing some SOAP encoded value or a
reference to another XML node (a multiRef).  This function will
resolve the multiRef reference, if any, than call a TYPE specific
decode function to perform the actual decoding.

(fn TYPE NODE)
(defalias 'soap-decode-type #[514 "\305
\306\"\211\203h\3072\342\310
\"A\211\203\311\307\"\210\210\312\313\"\204'\314\315\"\210\316\317\"	\211\203]\211@\211\320\305\"\206<\321\266\202
\232\203U\322\"
BB\311\307\"\266\210
A\266\202\202,\210\314\323\"\262
0\202\342\324\n\"\211@\206r
A@\206y\f\3258\326\327\"\330\232?\205\337<\203\305\3072\337\211\205\277\211@\331
!\332N\3331\253\211\"0\202\255\210\334\211\203\266\311\307\"\210\266
A\266\202\202\223\262
0\202\337\331!\332N\211\204\331\335\336\337\334\331	!C$\210\211\"\262
+\262
\207" [soap-decoded-multi-refs soap-multi-refs soap-local-xmlns soap-default-xmlns soap-target-xmlns xml-get-attribute-or-nil href done assoc throw string-match "^#\\(.*\\)$" error "Invalid multiRef: %s" match-string 1 id "" soap-decode-type "Cannot find href %s" soap-extract-xmlns 2 soap-xml-get-attribute-or-nil1 xsi:nil "true" soap-type-of soap-decoder (error) nil cl--assertion-failed decoder "no soap-decoder for %s type"] 11 (#$ . 210891)])
#@58 Decode NODE using type information inside it.

(fn NODE)
(defalias 'soap-decode-any-type #[257 "\301
\302\"\211\203
\303
!\262
\211\203*\304
\305#\211\203!\306
\"\202%\307\310\"\262
\202n
\211AA\262
\211G\311U\203B\211@;\203B\211@\202l\312
\211\203g\211@\211;\204`\211\211@\262
\313!

BB\262\266
A\266\202\202D\210\211\237\262
\262
\207" [soap-current-wsdl soap-xml-get-attribute-or-nil1 xsi:type soap-l2fq soap-wsdl-get soap-xs-type-p soap-decode-type error "Node has unknown type: %s" 1 nil soap-decode-any-type] 10 (#$ . 212245)])
#@70 Decode NODE as an Array using type information inside it.

(fn NODE)
(defalias 'soap-decode-array #[257 "\301
\302\"\303\211AA\262
\303\203*\304\305\306#\262\307\310!\311#\262\204*\312\313\"\210
\211\203O\211@\211:\203H\203A\314\"\202D\315
!B\262
A\266\202\202+\210\211\237\207" [soap-current-wsdl soap-xml-get-attribute-or-nil1 soapenc:arrayType nil replace-regexp-in-string "\\[[0-9]+\\]\\'" "" soap-wsdl-get soap-l2fq soap-xs-type-p error "Soap-decode-array: node has unknown type: %s" soap-decode-type soap-decode-any-type] 10 (#$ . 212803)])
(byte-code "\300\301!\203\301\302\303\"\210\202\304\302\305\306#\210\304\302\307\303#\210\300\207" [fboundp define-error soap-error "SOAP error" put error-conditions (error soap-error) error-message] 4)
#@183 Parse the SOAP envelope in NODE and return the response.
OPERATION is the WSDL operation for which we expect the response,
WSDL is used to decode the NODE.

(fn NODE OPERATION WSDL)
(defalias 'soap-parse-envelope #[771 "\304\"\211@\206\n	
A@\206\n\3058\306\211@\262
!\307=\2042\310\311\312\313\306\211@\262
!C$\210\314\315\"\314\316\"@\314
\317\"@\211\203o\320
\321\"@\211\211AA\262
\242\262
\320\322\"@\211\211AA\262
\242\262
\320\323\"\324\325E\"\210\202d\210\326!>\204\200\324\327\330D\"\210\331H\332=\203\214\211\202\260\3332\260\211\211AA\262
\211\205\255\211@\211:\203\246\334\333\"\210
A\266\202\202\226\262
0\335
%\262
\266\202+\207" [soap-local-xmlns soap-default-xmlns soap-target-xmlns cl-struct-soap-bound-operation-tags soap-extract-xmlns 2 soap-l2wk soap:Envelope cl--assertion-failed (eq (soap-l2wk (xml-node-name node)) 'soap:Envelope) "expecting soap:Envelope node, got %s" nil soap-xml-get-children1 soap:Header soap:Body soap:Fault xml-get-children faultcode faultstring detail signal soap-error type-of wrong-type-argument soap-bound-operation 5 literal found throw soap-parse-response] 15 (#$ . 213586)])
#@489 Parse RESPONSE-NODE and return the result as a LISP value.
OPERATION is the WSDL operation for which we expect the response,
WSDL is used to decode the NODE.

SOAP-HEADERS is a list of the headers of the SOAP envelope or nil
if there are no headers.

SOAP-BODY is the body of the SOAP envelope (of which
RESPONSE-NODE is a sub-node).  It is used in case RESPONSE-NODE
reference multiRef parts which are external to RESPONSE-NODE.

(fn RESPONSE-NODE OPERATION WSDL SOAP-HEADERS SOAP-BODY)
(defalias 'soap-parse-response #[1285 "\306!	>\204\307\310\311D\"\210\312H\306!	>\204%\307\310\311D\"\210\313H\306!\n>\2047\307\310\314D\"\210
\313HA\315\"\211@\206F\f
A@\206M
\3168\317=\203\212\320	\211@\262
!\321
	\322#\211=\204\210\323\324\306!%>\204\202\307\310\325	D\"\210\312H#\210\266\326\327\330\"\326&'\306!(>\204\245\307\310\331D\"\210\332H\211\203\226
\211@\211@
A\326\333\267\202]
\327\"@\202^
\3342^
\306
!)>\204\331\307\310\335D\"\210\f\313H\336\306!%>\204\357\307\310\325D\"\210\316H\"A\211\306!%>\204
\307\310\325D\"\210\312HB\337\340\341\"\211AA\262
\"\211\205U
\211@\211:\203N
\315
\"\211@\206.
\f
A@\2065

\3168\320\211@\262
!\232\203L
\342\334\"\210+\210
A\266\202\202
\262
\266\2030\202^
\326\262
\211\204
\323\343\306\f!%>\204x
\307\310\325D\"\210\312H#\210\344\"\211\203\215
\211B\262\266
A\266\202\202\250\210*\211\262
+\262
)\207" [soap-current-wsdl cl-struct-soap-bound-operation-tags cl-struct-soap-operation-tags soap-local-xmlns soap-default-xmlns soap-target-xmlns type-of signal wrong-type-argument soap-bound-operation 1 5 soap-operation soap-extract-xmlns 2 encoded soap-l2fq soap-wsdl-get soap-message-p error "Unexpected message: got %s, expecting %s" soap-element nil xml-get-children multiRef soap-message 3 #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (encoded 186 literal 195)) found soap-wsdl assoc append mapcar #[257 "\211\211AA\262
@\207" [] 3 "\n\n(fn HEADER)"] throw "Soap-parse-response(%s): cannot find message part %s" soap-decode-type cl-struct-soap-element-tags soap-decoded-multi-refs soap-multi-refs cl-struct-soap-message-tags cl-struct-soap-wsdl-tags] 25 (#$ . 214762)])
#@272 Encode XML attributes for VALUE according to TYPE.
This is a generic function which determines the attribute encoder
for the type and calls that specialized function to do the work.

Attributes are inserted in the current buffer at the current
position.

(fn VALUE TYPE)
(defalias 'soap-encode-attributes #[514 "\300
!\301N\211\204\302\303\304\305\300!C$\210\211\"\207" [soap-type-of soap-attribute-encoder cl--assertion-failed attribute-encoder "no soap-attribute-encoder for %s type" nil] 9 (#$ . 217023)])
#@314 Encode the VALUE using TYPE.
The resulting XML data is inserted in the current buffer
at (point)/

TYPE is one of the soap-*-type structures which defines how VALUE
is to be encoded.  This is a generic function which finds an
encoder function based on TYPE and calls that encoder to do the
work.

(fn VALUE TYPE)
(defalias 'soap-encode-value #[514 "\302
!\303N\211\204\304\305\306\307\302!C$\210\211\"\266\310
!>\204)\311\312\313D\"\210\211\314H\205R\310
!>\204>\311\312\313D\"\210\211\314H\211	\235\203K	\202P\211	B\211\262
\207" [cl-struct-soap-element-tags soap-encoded-namespaces soap-type-of soap-encoder cl--assertion-failed encoder "no soap-encoder for %s type" nil type-of signal wrong-type-argument soap-element 2] 9 (#$ . 217545)])
#@323 Create the body of a SOAP request for OPERATION in the current buffer.
PARAMETERS is a list of parameters supplied to the OPERATION.

The OPERATION and PARAMETERS are encoded according to the WSDL
document.  SERVICE-URL should be provided when WS-Addressing is
being used.

(fn OPERATION PARAMETERS &optional SERVICE-URL)
(defalias 'soap-encode-body #[770 "\305!>\204\306\307\310D\"\210\311H\305!>\204\"\306\307\310D\"\210\312H\305!	>\2044\306\307\313D\"\210
\314HA\305!	>\204G\306\307\313D\"\210\315H\211\316\316\211:\203t@\262:\203t@\262B
B\262
A\262A\262\202P\211\237\266\205
GGU\204\237\317\320\305!\n>\204\224\306\307\321	D\"\210\311HG\nG$\210\305!>\204\260\306\307\310\nD\"\210\315H\305!	>\204\305\306\307\313D\"\210\322H
\203\200
\323c\210\211\203\357\324\235\203\336\210\202\342\324B\325
\326\261\210\327\330\261\210
\211\203|
\211@\211@
A@\305!\f>\204\n
\306\307\331D\"\210
\315H\236\332
@@\"A\3338A
\334=\203`
\305
!\n>\2040
\306\307\321D\"\210\211\333H\203X
\305
!\n>\204E
\306\307\321D\"\210\211\333H\211\235\203S
\210\202W
\211B\210\335\336!\337\261\210\340\"\210
\334=\203s
\341\336!\337\261\210\266
A\266\202\202\360\210\342c\210\266\343c\210\334=\203\315
\305!\n>\204\233
\306\307\321D\"\210\333H\203\304
\305!\n>\204\261
\306\307\321D\"\210\333H\211\235\203\277
\210\202\303
\211B\210\335\336!\337\261\210\305!\f>\204\334
\306\307\331D\"\210\315H\211\203/\211@\211@
A\332\"A\305
!>\204\306\307\310D\"\210\f\314H\203!\305!>\204\306\307\310D\"\210
\314H\235\203&\340
\"\210\266
A\266\202\202\337
\210\334=\203?\341\336!\337\261\210\344c\207" [cl-struct-soap-bound-operation-tags cl-struct-soap-operation-tags cl-struct-soap-element-tags soap-encoded-namespaces cl-struct-soap-message-tags type-of signal wrong-type-argument soap-bound-operation 1 5 soap-operation 4 3 nil error "Wrong number of parameters for %s: expected %d, got %s" soap-element 7 "<soap:Header>\n" "wsa" "<wsa:Action>" "</wsa:Action>\n" "<wsa:To>" "</wsa:To>\n" soap-message assoc 2 encoded "<" soap-element-fq-name ">\n" soap-encode-value "</" "</soap:Header>\n" "<soap:Body>\n" "</soap:Body>\n"] 21 (#$ . 218311)])
#@240 Create a SOAP request envelope for OPERATION using PARAMETERS.
WSDL is the wsdl document used to encode the PARAMETERS.
SERVICE-URL should be provided when WS-Addressing is being used.

(fn OPERATION PARAMETERS WSDL &optional SERVICE-URL)
(defalias 'soap-create-envelope #[1027 "\304\305!r\211q\210\306\307\310\311\312!\313\"\314$\216\315\316!>\204%\317\320\321D\"\210\322H
\323#\210eb\210\324c\210\211\325=\203B\326c\210	\211\203\201\211@\327
\330\261\210\331
\n\"A\211\204s\331\316\n!>\204k\317\320\332\fD\"\210	\322H\"A\262
\211c\210\333c\266
A\266\202\202C\210\334c\210db\210\335c\210)\266\336 *\207" [cl-struct-soap-bound-operation-tags soap-encoded-namespaces soap-well-known-xmlns cl-struct-soap-wsdl-tags generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 ("xsi" "soap" "soapenc") type-of signal wrong-type-argument soap-bound-operation 5 soap-encode-body "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<soap:Envelope\n" encoded "    soapenc:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\"\n" "    xmlns:" "=\"" assoc soap-wsdl "\"\n" ">\n" "</soap:Envelope>\n" buffer-string] 16 (#$ . 220560)])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\207" [custom-declare-variable soap-debug funcall function #[0 "\300\207" [nil] 1] "When t, enable some debugging facilities." :type boolean :group soap-client] 8)
#@92 Return the WSDL port having SERVICE name.
Signal an error if not found.

(fn WSDL SERVICE)
(defalias 'soap-find-port #[514 "\3022B\303!>\204\304\305\306D\"\210
\307H\211\205?\211@\303!	>\204,\304\305\310D\"\210
\311H\232\2038\312\302\"\210
A\266\202\202\262
0\206I\313\314\"\207" [cl-struct-soap-wsdl-tags cl-struct-soap-element-tags found type-of signal wrong-type-argument soap-wsdl 4 soap-element 1 throw error "Unknown SOAP service: %s"] 9 (#$ . 221998)])
#@111 Inside PORT, find OPERATION-NAME, a `soap-port-type'.
Signal an error if not found.

(fn PORT OPERATION-NAME)
(defalias 'soap-find-operation #[514 "\303!>\204\304\305\306D\"\210
\307H\310\303!	>\204#\304\305\311D\"\210\307H\"\211\206D\312\313\303!\n>\204?\304\305\314	D\"\210\315H#\207" [cl-struct-soap-port-tags cl-struct-soap-binding-tags cl-struct-soap-element-tags type-of signal wrong-type-argument soap-port 4 gethash soap-binding error "No operation %s for SOAP service %s" soap-element 1] 11 (#$ . 222482)])
#@176 Return the number of arguments required by a soap operation.
WSDL, SERVICE, OPERATION-NAME and PARAMETERS are as described in
`soap-invoke'.

(fn WSDL SERVICE OPERATION-NAME)
(defalias 'soap-operation-arity #[771 "\302\"\303
\"\304
!>\204\305\306\307D\"\210\211\310H\304
!	>\204)\305\306\311D\"\210\211\312HG\207" [cl-struct-soap-bound-operation-tags cl-struct-soap-operation-tags soap-find-port soap-find-operation type-of signal wrong-type-argument soap-bound-operation 1 soap-operation 3] 10 (#$ . 223023)])
#@391 Implement `soap-invoke' and `soap-invoke-async'.
If CALLBACK is non-nil, operate asynchronously, then call CALLBACK as (apply
CALLBACK RESPONSE CBARGS), where RESPONSE is the SOAP invocation result.
If CALLBACK is nil, operate synchronously.  WSDL, SERVICE,
OPERATION-NAME and PARAMETERS are as described in `soap-invoke'.

(fn CALLBACK CBARGS WSDL SERVICE OPERATION-NAME &rest PARAMETERS)
(defalias 'soap-invoke-internal #[1413 "\306\"\307
\"\310\311\312\313\314\f\315\n!>\204#\316\317\320\fD\"\210	\321H$\322\"\323\324\325\326\313\315\n!	>\204@\316\317\327\fD\"\210	\330H\322\"\326QB\331\332BD012\203\206\333\315!>\204l\316\317\320D\"\210\321H\334\335\336\337\340\n$\341\"\342\343%\"\202\354\344\315!>\204\226\316\317\320D\"\210\321H!\3451\332\3461\316r\211q\2103\204\257\347\350!\2104\203\3013\351V\203\301\352\3533\"\210\354\355 	#)00\202\3520\316
@A\"\262
\202\3524\203\343\356!\210\347\357!!\262
\262
.\207" [cl-struct-soap-port-tags cl-struct-soap-bound-operation-tags url-request-extra-headers url-http-attempt-keepalives url-mime-charset-string url-request-data soap-find-port soap-find-operation "POST" "soap-client.el" "1.0" encode-coding-string soap-create-envelope type-of signal wrong-type-argument soap-port 3 utf-8 "utf-8;q=1, iso-8859-1;q=0.5" t "SOAPAction" "\"" soap-bound-operation 2 "Content-Type" "text/xml; charset=utf-8" url-retrieve make-byte-code 257 "p\304\305\306\307\310!\311\"\312$\216\313\314\"\211\203\315
@A\"\202(\316\300\317\320 \303\302#\301#\262
)\207" vconcat vector [make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-live-p kill-buffer] 2 plist-get :error signal apply soap-parse-envelope soap-parse-server-response] 9 "\n\n(fn STATUS)" url-retrieve-synchronously (error) (soap-error) error "No HTTP response from server" 299 warn "Error in SOAP response: HTTP code %s" soap-parse-envelope soap-parse-server-response pop-to-buffer error-message-string url-package-version url-package-name url-request-method url-http-response-status soap-debug] 21 (#$ . 223550)])
#@790 Invoke a SOAP operation and return the result.

WSDL is used for encoding the request and decoding the response.
It also contains information about the WEB server address that
will service the request.

SERVICE is the SOAP service to invoke.

OPERATION-NAME is the operation to invoke.

PARAMETERS -- the remaining parameters are used as parameters for
the SOAP request.

NOTE: The SOAP service provider should document the available
operations and their parameters for the service.  You can also
use the `soap-inspect' function to browse the available
operations in a WSDL document.

NOTE: `soap-invoke' base64-decodes xsd:base64Binary return values
into unibyte strings; these byte-strings require further
interpretation by the caller.

(fn WSDL SERVICE OPERATION-NAME &rest PARAMETERS)
(defalias 'soap-invoke #[899 "\300\301\302\211&\207" [apply soap-invoke-internal nil] 12 (#$ . 225650)])
#@319 Like `soap-invoke', but call CALLBACK asynchronously with response.
CALLBACK is called as (apply CALLBACK RESPONSE CBARGS), where
RESPONSE is the SOAP invocation result.  WSDL, SERVICE,
OPERATION-NAME and PARAMETERS are as described in `soap-invoke'.

(fn CALLBACK CBARGS WSDL SERVICE OPERATION-NAME &rest PARAMETERS)
(defalias 'soap-invoke-async #[1413 "\204\300\301!\210\302\303&\207" [error "Callback argument is nil" apply soap-invoke-internal] 14 (#$ . 226560)])
(provide 'soap-client)